Merge lp:~alecu/unity-lens-music/ubuntuone-webservices into lp:unity-lens-music

[Alejandro J. Cura]

Call every webservice with libsoup, using OAuth when needed

This branch adds code to call the Ubuntu One webservices needed by dash payments, using libsoup and OAuth. It adds a few unit tests too.

[Michal Hruby (mhr3)]

56 + public unowned string sign_url2(string url, string? postargs,

Looking at the docs, it says that you need to free the return, so s/unowned//, plus the postargs should be "out string postargs" as it's also a return (out params are nullable by default).

118 + internal Soup.SessionAsync http_session;

"internal" is a special keyword used when building libraries in vala (internal symbols are callable by other parts of the library, but not by the consumers), pls use private/public as appropriate.

177 + public string nickname {
178 + get { return _nickname; }
179 + }
+ other instances

No need for the extra private variable, use "public string x { get; private set; }"

243 + credentials_management.find_credentials ();
244 + yield;

Wouldn't it be better if find_credentials() itself was async? Then you wouldn't need the signals and you could just return the credentials / throw an error in the async method.

275 + internal virtual async void fetch_account () throws PurchaseError

Nothing wrong here, nice async method ;)

285 + var result = (string) message.response_body.data;

278 + queue_signed_webservice_call ("GET", ACCOUNT_URI, (session, message) => {

You're using this multiple times, perhaps add a helper async method that takes method + uri and returns flattened Soup.MessageBody?

.data could be null, no? Or does the flatten() cause possible null to become ""?

576 + return 0;

You should return result of Test.run ()

852 + MainLoop mainloop = new MainLoop ();
853 + purchase_service.refetch_payment_info.begin((obj, res) => {
854 + mainloop.quit ();
855 + try {
856 + purchase_service.refetch_payment_info.end (res);
857 + } catch (PurchaseError e) {
858 + error ("Can't fetch payment info: %s", e.message);
859 + }
860 + });
861 + mainloop.run ();

I remember you mentioned on IRC that you weren't sure how to do async tests with vala, so yep, this is the way, usually we just have a wrapper for the mainloop.run() which also adds a timeout, so the test fails eventually if there's no response. Usually using "assert (run_with_timeout (mainloop));"

review: Needs Fixing

[lp:~alecu/unity-lens-music/ubuntuone-webservices]

116. By Alejandro J. Cura on 2012-12-06

merged with trunk

117. By Alejandro J. Cura on 2012-12-06

fixes requested in merge proposal

118. By Alejandro J. Cura on 2012-12-06

use purchase sku to get payment method

[Alejandro J. Cura (alecu)]

Thanks for your through review!

> 56 + public unowned string sign_url2(string url, string? postargs,
>
> Looking at the docs, it says that you need to free the return, so s/unowned//,
> plus the postargs should be "out string postargs" as it's also a return (out
> params are nullable by default).

Fixed as requested.

> 118 + internal Soup.SessionAsync http_session;
>
> "internal" is a special keyword used when building libraries in vala (internal
> symbols are callable by other parts of the library, but not by the consumers),
> pls use private/public as appropriate.

Fixed all unnecessary uses of "internal". A few remain, as needed in some tests.

> 177 + public string nickname {
> 178 + get { return _nickname; }
> 179 + }
> + other instances
>
> No need for the extra private variable, use "public string x { get; private
> set; }"

Fixed as requested.

> 243 + credentials_management.find_credentials ();
> 244 + yield;
>
> Wouldn't it be better if find_credentials() itself was async? Then you
> wouldn't need the signals and you could just return the credentials / throw an
> error in the async method.

find_credentials is defined in lp:ubuntu-sso-client, and used via dbus. We found some timeout problems in the python dbus bindings that were solved by using signals instead, so most of the client code in Ubuntu SSO Client and Ubuntu One already uses this pattern. I agree that it would simplify things, but too much code depends on this dbus API as is, and it's not easy to change just for this case.

> 278 + queue_signed_webservice_call ("GET", ACCOUNT_URI,
> (session, message) => {
>
> You're using this multiple times, perhaps add a helper async method that takes
> method + uri and returns flattened Soup.MessageBody?

As suggested, I created a helper async method for the repeated instances. There are still at least two places which did not follow the same pattern (one used different http object and error codes, the other was not async), so I kept the existing code for those.

> 285 + var result = (string) message.response_body.data;
>
> .data could be null, no? Or does the flatten() cause possible null to become
> ""?

I just checked, and if .data is null, flatten() does the right thing and turns it into an empty string.

> 576 + return 0;
>
> You should return result of Test.run ()

Fixed.

> 852 + MainLoop mainloop = new MainLoop ();
> 853 + purchase_service.refetch_payment_info.begin((obj, res) => {
> 854 + mainloop.quit ();
> 855 + try {
> 856 + purchase_service.refetch_payment_info.end (res);
> 857 + } catch (PurchaseError e) {
> 858 + error ("Can't fetch payment info: %s", e.message);
> 859 + }
> 860 + });
> 861 + mainloop.run ();
>
> I remember you mentioned on IRC that you weren't sure how to do async tests
> with vala, so yep, this is the way, usually we just have a wrapper for the
> mainloop.run() which also adds a timeout, so the test fails eventually if
> there's no response. Usuall...

[Michal Hruby (mhr3)]

Awesome, /me happy now :)

review: Approve

[lp:~alecu/unity-lens-music/ubuntuone-webservices]

119. By Alejandro J. Cura on 2012-12-11

Link bug #1088935

120. By Alejandro J. Cura on 2012-12-11

Fixes requested for the packaging

121. By Alejandro J. Cura on 2012-12-11

merged with trunk

122. By Alejandro J. Cura on 2012-12-11

Packaging fixes requested on the review

=== modified file 'configure.ac'
--- configure.ac	2012-11-14 14:45:52 +0000
+++ configure.ac	2012-12-12 00:01:27 +0000
@@ -63,7 +63,9 @@
                   dee-1.0 >= 1.0.7
                   sqlite3 >= 3.7.7
                   gee-1.0
-		  json-glib-1.0
+                  json-glib-1.0
+                  libsoup-2.4
+                  oauth
                   unity >= 6.90.0
                   unity-extras >= 6.90.0
                   tdb >= 1.2.6)

=== modified file 'debian/changelog'
--- debian/changelog	2012-12-10 16:34:35 +0000
+++ debian/changelog	2012-12-12 00:01:27 +0000
@@ -1,3 +1,10 @@
+unity-lens-music (6.8.1daily12.12.05-0ubuntu2) UNRELEASED; urgency=low
+
+  * debian/control:
+    - added libsoup2.4-dev and liboauth-dev build dependencies
+
+ -- Alejandro J. Cura <[e-mail]>  Tue, 11 Dec 2012 20:54:55 -0300
+
 unity-lens-music (6.8.1daily12.12.05-0ubuntu1) raring; urgency=low
 
   [ Michael Terry ]

=== modified file 'debian/control'
--- debian/control	2012-12-10 16:34:35 +0000
+++ debian/control	2012-12-12 00:01:27 +0000
@@ -11,6 +11,8 @@
                libglib2.0-dev (>= 2.27),
                libgee-dev,
                libjson-glib-dev,
+               libsoup2.4-dev,
+               liboauth-dev,
                libdee-dev (>= 1.0.7),
                libsqlite3-dev (>= 3.7.7),
                libunity-dev (>= 6.90.0),

=== modified file 'po/POTFILES.skip'
--- po/POTFILES.skip	2012-08-17 07:56:11 +0000
+++ po/POTFILES.skip	2012-12-12 00:01:27 +0000
@@ -5,3 +5,5 @@
 src/banshee-scope.c
 src/rhythmbox-scope.c
 src/musicstore-scope.c
+src/ubuntuone-webservices.c
+tests/unit/ubuntuone-webservices.c

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2012-11-14 14:45:52 +0000
+++ src/Makefile.am	2012-12-12 00:01:27 +0000
@@ -69,6 +69,8 @@
 
 unity_musicstore_daemon_VALAFLAGS = \
   --pkg json-glib-1.0 \
+  --pkg oauth \
+  --pkg libsoup-2.4 \
   $(unity_music_daemon_VALAFLAGS)
 
 unity_musicstore_daemon_LDADD = \
@@ -88,7 +90,9 @@
   musicstore-filter-parser-genre.vala \
   musicstore-scope.vala \
   simple-scope.vala \
-  track.vala
+  track.vala \
+  ubuntuone-webservices.vala \
+  $(NULL)
 
 unity_musicstore_daemon_SOURCES = \
   $(unity_musicstore_daemon_VALASOURCES:.vala=.c) \

=== added file 'src/oauth.vapi'
--- src/oauth.vapi	1970-01-01 00:00:00 +0000
+++ src/oauth.vapi	2012-12-12 00:01:27 +0000
@@ -0,0 +1,19 @@
+/* Minimal vapi for OAuth */
+[CCode (cheader_filename="oauth.h")]
+namespace OAuth {
+
+    [CCode (cheader_filename="oauth.h", cprefix="OA_")]
+    public enum Method {
+        HMAC,
+        RSA,
+        PLAINTEXT
+    }
+
+    [CCode (cheader_filename="oauth.h", cprefix="oauth_")]
+    public string sign_url2(string url, out string postargs,
+                            OAuth.Method method,
+                            string? http_method,
+                            string c_key, string c_secret,
+                            string t_key, string t_secret);
+
+}

=== added file 'src/ubuntuone-webservices.vala'
--- src/ubuntuone-webservices.vala	1970-01-01 00:00:00 +0000
+++ src/ubuntuone-webservices.vala	2012-12-12 00:01:27 +0000
@@ -0,0 +1,342 @@
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program 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/>.
+ *
+ * Authored by Alejandro J. Cura <[e-mail]>
+ *
+ */
+
+using Soup;
+
+[DBus (name = "com.ubuntuone.CredentialsManagement")]
+interface CredentialsManagement : GLib.Object {
+    public signal void credentials_found (HashTable <string, string> info);
+    public signal void credentials_error ();
+
+    [DBus (name = "find_credentials")]
+    public abstract void find_credentials () throws IOError;
+}
+
+const string WEBAPI_URI = "https://edge.one.ubuntu.com/";
+const string ACCOUNT_URI = WEBAPI_URI + "api/account";
+const string PAYMENT_METHOD_URI = WEBAPI_URI + "music-store/api/1/user/retrieve-payment-method?purchase_sku=%s";
+const string PURCHASE_WITH_DEFAULT_PAYMENT_URI = WEBAPI_URI + "music-store/api/1/user/purchase-with-default-payment?purchase_sku=%s&authentication=%s";
+const string AUTHENTICATION_URI = "https://login.staging.ubuntu.com/api/1.1/authentications";
+const string AUTHENTICATE_PARAMS = "ws.op=authenticate&token_name=Purchase_Token";
+const int PASSWORD_CACHE_SECONDS = 300;
+const int PAYMENT_METHOD_CACHE_SECONDS = 120;
+
+namespace Ubuntuone.Webservice
+{
+    public errordomain PurchaseError
+    {
+        PURCHASE_ERROR,
+        WRONG_PASSWORD_ERROR,
+        UNSPECIFIED_ERROR
+    }
+
+    public class PurchaseService : GLib.Object
+    {
+        internal Soup.SessionAsync http_session;
+        Soup.SessionAsync http_session_sso;
+        CredentialsManagement credentials_management;
+        public string nickname { get; private set; default = null; }
+        public string email { get; private set; default = null; }
+        public string selected_payment_method { get; internal set; default = null; }
+        public string consumer_key { get; private set; default = null; }
+        public string token { get; private set; default = null; }
+        internal DateTime _selected_payment_method_expiry;
+        DateTime _password_expiry;
+        internal HashTable <string, string> _ubuntuone_credentials = null;
+
+        construct {
+            http_session = build_http_session ();
+            http_session_sso = build_http_session ();
+
+            reset_payment_method_cache (0);
+            reset_password_cache (0);
+
+            credentials_management = build_credentials_management ();
+        }
+
+        internal Soup.SessionAsync build_http_session ()
+        {
+            var session = new Soup.SessionAsync ();
+            session.user_agent = "%s/%s (libsoup)".printf("UbuntuOneMusicstoreLens", "1.0");
+            return session;
+        }
+
+        internal DateTime now ()
+        {
+            return new DateTime.now_utc ();
+        }
+
+        internal bool expired_payment_method_cache ()
+        {
+            return _selected_payment_method_expiry.compare (now ()) <= 0;
+        }
+
+        internal void reset_payment_method_cache (int seconds_from_now)
+        {
+            _selected_payment_method_expiry = now ().add_seconds (seconds_from_now);
+        }
+
+        internal void reset_password_cache (int seconds_from_now)
+        {
+            _password_expiry = now ().add_seconds (seconds_from_now);
+        }
+
+        internal virtual CredentialsManagement build_credentials_management ()
+        {
+            try {
+                return Bus.get_proxy_sync (BusType.SESSION, "com.ubuntuone.Credentials",
+                                           "/credentials", DBusProxyFlags.DO_NOT_AUTO_START);
+            } catch (IOError e) {
+                error ("Can't connect to DBus: %s", e.message);
+            }
+        }
+
+        public bool ready_to_purchase {
+            get { return selected_payment_method != null; }
+        }
+
+        internal Json.Object parse_json (string json_string) throws GLib.Error
+        {
+            var parser = new Json.Parser();
+            parser.load_from_data(json_string, -1);
+            return parser.get_root().get_object();
+        }
+
+        internal void parse_account_json (string json_string) throws GLib.Error
+        {
+            var root_object = parse_json (json_string);
+            nickname = root_object.get_string_member("nickname");
+            email = root_object.get_string_member("email");
+        }
+
+        internal void parse_payment_method_json (string json_string) throws GLib.Error
+        {
+            var root_object = parse_json (json_string);
+            Json.Object payload = root_object.get_object_member("payload");
+            selected_payment_method = payload.get_string_member("selected_payment_method");
+        }
+
+        internal void parse_authentication_json (string json_string) throws GLib.Error
+        {
+            var root_object = parse_json (json_string);
+            consumer_key = root_object.get_string_member("consumer_key");
+            token = root_object.get_string_member("token");
+        }
+
+        internal string parse_purchase_json (string json_string) throws GLib.Error
+        {
+            var root_object = parse_json (json_string);
+            Json.Object payload = root_object.get_object_member("payload");
+            return payload.get_string_member("open_url");
+        }
+
+        internal virtual async void fetch_credentials () throws PurchaseError
+        {
+            PurchaseError error = null;
+
+            ulong found_handler = credentials_management.credentials_found.connect ((credentials) => {
+                _ubuntuone_credentials = credentials;
+                debug ("got credentials");
+                fetch_credentials.callback ();
+            });
+            ulong error_handler = credentials_management.credentials_error.connect (() => {
+                error = new PurchaseError.PURCHASE_ERROR ("Can't get Ubuntu One tokens.");
+                fetch_credentials.callback ();
+            });
+
+            try {
+                credentials_management.find_credentials ();
+                yield;
+            } catch (IOError e) {
+                error = new PurchaseError.PURCHASE_ERROR ("Can't get Ubuntu One tokens: %s", e.message);
+            }
+
+            credentials_management.disconnect (found_handler);
+            credentials_management.disconnect (error_handler);
+
+            if (error != null) {
+                debug ("Can't get Ubuntu One tokens: %s", error.message);
+                throw error;
+            }
+        }
+
+        string oauth_sign (string uri)
+        {
+            return OAuth.sign_url2(uri, null,
+                                   OAuth.Method.PLAINTEXT, "GET",
+                                   _ubuntuone_credentials["consumer_key"],
+                                   _ubuntuone_credentials["consumer_secret"],
+                                   _ubuntuone_credentials["token"],
+                                   _ubuntuone_credentials["token_secret"]);
+        }
+
+        internal virtual async PurchaseError call_api (string method, string uri, out string response)
+        {
+            PurchaseError error = null;
+            var signed_uri = oauth_sign (uri);
+            var message = new Soup.Message (method, signed_uri);
+            http_session.queue_message (message, (session, message) => {
+                if (message.status_code != Soup.KnownStatusCode.OK) {
+                    debug ("Web request failed: HTTP %u %s - %s",
+                           message.status_code, message.reason_phrase, uri);
+                    error = new PurchaseError.PURCHASE_ERROR (message.reason_phrase);
+                }
+                call_api.callback ();
+            });
+            yield;
+            message.response_body.flatten ();
+            response = (string) message.response_body.data;
+            return error;
+        }
+
+        internal virtual async void fetch_account () throws PurchaseError
+        {
+            string response;
+            PurchaseError error = yield call_api ("GET", ACCOUNT_URI, out response);
+
+            if (error != null) {
+                debug ("Error while fetching U1 account: %s.", error.message);
+                throw error;
+            }
+
+            try {
+                parse_account_json (response);
+                debug ("got account");
+            } catch (GLib.Error e) {
+                debug ("Error while parsing U1 account: %s.", e.message);
+                throw new PurchaseError.PURCHASE_ERROR (e.message);
+            }
+        }
+
+        internal virtual async void fetch_payment_method (string purchase_sku) throws PurchaseError
+        {
+            string response;
+            var uri = PAYMENT_METHOD_URI.printf (purchase_sku);
+            PurchaseError error = yield call_api ("GET", uri, out response);
+
+            if (error != null) {
+                debug ("Error while fetching payment method: %s.", error.message);
+                throw error;
+            }
+
+            try {
+                parse_payment_method_json (response);
+                debug ("got payment method");
+            } catch (GLib.Error e) {
+                debug ("Error while getting payment method: %s.", e.message);
+                throw new PurchaseError.PURCHASE_ERROR (e.message);
+            }
+        }
+
+        internal virtual async void refetch_payment_info (string purchase_sku) throws PurchaseError
+        {
+            yield fetch_credentials ();
+            yield fetch_account ();
+            yield fetch_payment_method (purchase_sku);
+            reset_payment_method_cache (PAYMENT_METHOD_CACHE_SECONDS);
+        }
+
+        public async void fetch_payment_info (string purchase_sku) throws PurchaseError
+        {
+            if (expired_payment_method_cache ())
+            {
+                debug ("refetching");
+                yield refetch_payment_info (purchase_sku);
+            } else {
+                debug ("in cache");
+            }
+        }
+
+        internal virtual void _do_sso_webcall (Soup.Message message, string password)
+        {
+            var handler = http_session_sso.authenticate.connect ((session, message, auth, retrying) => {
+                if (!retrying) {
+                    auth.authenticate (email, password);
+                }
+            });
+            http_session_sso.send_message (message);
+            http_session_sso.disconnect (handler);
+        }
+
+        internal virtual string authenticated_sso_webcall (string method, string uri, string operation, string password)
+            throws PurchaseError
+        {
+            var message = new Soup.Message (method, uri);
+            message.set_request ("application/x-www-form-urlencoded", Soup.MemoryUse.COPY, operation.data);
+            _do_sso_webcall (message, password);
+            if (message.status_code != Soup.KnownStatusCode.OK) {
+                debug ("Authentication request failed: HTTP %u", message.status_code);
+                debug ("Reason: %s", message.reason_phrase);
+                if (message.status_code == Soup.KnownStatusCode.UNAUTHORIZED) {
+                    throw new PurchaseError.WRONG_PASSWORD_ERROR ("Wrong password");
+                }
+                throw new PurchaseError.PURCHASE_ERROR (message.reason_phrase);
+            }
+            message.response_body.flatten ();
+            return (string) message.response_body.data;
+        }
+
+        internal virtual string get_purchase_token (string password) throws PurchaseError
+        {
+            var result = authenticated_sso_webcall ("POST", AUTHENTICATION_URI, AUTHENTICATE_PARAMS, password);
+            try {
+                parse_authentication_json (result);
+            } catch (GLib.Error e) {
+                throw new PurchaseError.PURCHASE_ERROR (e.message);
+            }
+            return "%s:%s".printf (consumer_key, token);
+        }
+
+        internal virtual Soup.Message send_signed_webservice_call (string method, string uri)
+        {
+            var signed_uri = oauth_sign (uri);
+            var message = new Soup.Message (method, signed_uri);
+            http_session.send_message (message);
+            return message;
+        }
+
+        internal virtual void purchase_with_default_payment (string sku, string purchase_token) throws PurchaseError
+        {
+            var uri = PURCHASE_WITH_DEFAULT_PAYMENT_URI.printf (sku, purchase_token);
+            var message = send_signed_webservice_call ("GET", uri);
+
+            if (message.status_code != Soup.KnownStatusCode.OK) {
+                debug ("Purchase request failed: HTTP %u", message.status_code);
+                debug ("Reason: %s", message.reason_phrase);
+                throw new PurchaseError.PURCHASE_ERROR ("Purchase failed: %s".printf (message.reason_phrase));
+            }
+            try {
+                message.response_body.flatten ();
+                var result = (string) message.response_body.data;
+                var open_url = parse_purchase_json (result);
+                if (open_url != "") {
+                    throw new PurchaseError.PURCHASE_ERROR (open_url);
+                }
+            } catch (GLib.Error e) {
+                throw new PurchaseError.PURCHASE_ERROR (e.message);
+            }
+        }
+
+        public void purchase (string album_id, string password) throws PurchaseError
+        {
+            var purchase_token = get_purchase_token (password);
+            purchase_with_default_payment (album_id, purchase_token);
+        }
+    }
+}

=== modified file 'tests/unit/Makefile.am'
--- tests/unit/Makefile.am	2012-08-13 10:36:17 +0000
+++ tests/unit/Makefile.am	2012-12-12 00:01:27 +0000
@@ -1,4 +1,4 @@
-check_PROGRAMS = test-rhythmbox-parser
+check_PROGRAMS = test-rhythmbox-parser test-ubuntuone-purchases
 
 TESTS = $(check_PROGRAMS)
 
@@ -16,6 +16,9 @@
   --pkg gio-2.0 \
   --pkg gio-unix-2.0 \
   --pkg glib-2.0 \
+  --pkg json-glib-1.0 \
+  --pkg oauth \
+  --pkg libsoup-2.4 \
   --vapidir $(top_srcdir)/src \
   --pkg tdb \
   --pkg unity \
@@ -41,6 +44,13 @@
   $(top_srcdir)/src/track.vala \
   $(NULL)
 
+test_ubuntuone_purchases_LDADD = $(test_libs)
+
+test_ubuntuone_purchases_SOURCES = \
+  test-ubuntuone-purchases.vala \
+  $(top_srcdir)/src/ubuntuone-webservices.vala \
+  $(NULL)
+
 EXTRA_DIST = assertions.vapi
 CLEANFILES = *.stamp
 

=== added file 'tests/unit/test-ubuntuone-purchases.vala'
--- tests/unit/test-ubuntuone-purchases.vala	1970-01-01 00:00:00 +0000
+++ tests/unit/test-ubuntuone-purchases.vala	2012-12-12 00:01:27 +0000
@@ -0,0 +1,761 @@
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program 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/>.
+ *
+ * Authored by Alejandro J. Cura <[e-mail]>
+ *
+ */
+
+using Assertions;
+using Gee;
+using GLib;
+using Ubuntuone.Webservice;
+
+
+const string FAKE_URL = "http://fake/url";
+const string FAKE_PASSWORD = "PezEspada";
+const string FAKE_SKU = "fake_store:fake_album:id";
+const string FAKE_TOKEN = "a fake token";
+
+const string BROKEN_JSON = """
+    {
+        "a": "b",
+    $!@$# BROKEN!
+""";
+
+const string FAKE_JSON_ACCOUNT = """
+    {
+        "username": "mrbean",
+        "nickname": "Mr. Bean",
+        "email": "[e-mail]"
+    }
+""";
+
+
+const string FAKE_JSON_PAYMENT_METHOD = """
+    {
+        "meta": {
+            "status": "Ok"
+        },
+        "payload": {
+            "open_url": "",
+            "user_email": "[e-mail]",
+            "selected_payment_method": "Visa 1234"
+        }
+    }
+""";
+
+
+const string FAKE_JSON_AUTHENTICATION = """
+    {
+        "consumer_secret": "fake_secret", 
+        "token": "fake_token", 
+        "consumer_key": "fake_consumer_key", 
+        "name": "FAKE_TOKEN_NAME", 
+        "token_secret": "fake_token_secret"
+    }
+""";
+
+const string FAKE_JSON_PURCHASE = """
+    {
+        "meta": {
+            "status": "Ok"
+        },
+        "payload": {
+            "order_id": "1111",
+            "order_status": "OK",
+            "order_detail": "TBD",
+            "open_url": ""
+        }
+    }
+""";
+
+
+const string FAKE_JSON_PURCHASE_FAILURE = """
+    {
+        "meta": {
+            "status": "Ok"
+        },
+        "payload": {
+            "order_id": "1111",
+            "order_status": "PAYMENT_FAILURE",
+            "order_detail": "TBD",
+            "open_url": "http://slashdot.org/"
+        }
+    }
+""";
+
+
+public class Main
+{
+  public static int main (string[] args)
+  {
+    int result = run_tests (args);
+    // irl_test ();
+    return result;
+  }
+
+  static int run_tests (string[] args)
+  {
+    Test.init (ref args);
+
+    Test.add_data_func ("/Unit/PurchaseChecker/ParseAccount", test_parse_account);
+    Test.add_data_func ("/Unit/PurchaseChecker/ParseBrokenAccount", test_parse_broken_account);
+    Test.add_data_func ("/Unit/PurchaseChecker/ParsePaymentMethod", test_parse_payment_method);
+    Test.add_data_func ("/Unit/PurchaseChecker/ParseAuthentication", test_parse_authentication);
+    Test.add_data_func ("/Unit/PurchaseChecker/ReadyToPurchase", test_ready_to_purchase);
+    Test.add_data_func ("/Unit/PurchaseChecker/FetchPaymentInvalidated", test_fetch_payment_invalidated);
+    Test.add_data_func ("/Unit/PurchaseChecker/FetchPaymentCached", test_fetch_payment_cached);
+    Test.add_data_func ("/Unit/PurchaseChecker/ReFetchPayment", test_refetch_payment);
+    Test.add_data_func ("/Unit/PurchaseChecker/ReFetchPaymentSetsCache", test_refetch_payment_sets_cache);
+    Test.add_data_func ("/Unit/PurchaseChecker/FetchCredentials", test_fetch_credentials);
+    Test.add_data_func ("/Unit/PurchaseChecker/FetchCredentialsFails", test_fetch_credentials_fails);
+    Test.add_data_func ("/Unit/PurchaseChecker/FetchCredentialsFailsExtra", test_fetch_credentials_fails_extra);
+    Test.add_data_func ("/Unit/PurchaseChecker/FetchAccount", test_fetch_account);
+    Test.add_data_func ("/Unit/PurchaseChecker/FetchAccountFails", test_fetch_account_http_failure);
+    Test.add_data_func ("/Unit/PurchaseChecker/FetchAccountBrokenJson", test_fetch_account_wrong_json);
+    Test.add_data_func ("/Unit/PurchaseChecker/FetchPayment", test_fetch_payment);
+    Test.add_data_func ("/Unit/PurchaseChecker/FetchPaymentFails", test_fetch_payment_http_failure);
+    Test.add_data_func ("/Unit/PurchaseChecker/FetchPaymentBrokenJson", test_fetch_payment_wrong_json);
+    Test.add_data_func ("/Unit/PurchaseChecker/Purchase", test_purchase);
+    Test.add_data_func ("/Unit/PurchaseChecker/GetPurchaseToken", test_get_purchase_token);
+    Test.add_data_func ("/Unit/PurchaseChecker/GetPurchaseTokenBrokenJson", test_get_purchase_token_broken_json);
+    Test.add_data_func ("/Unit/PurchaseChecker/SsoWebcall", test_authenticated_sso_webcall);
+    Test.add_data_func ("/Unit/PurchaseChecker/SsoWebcallFails", test_authenticated_sso_webcall_fails);
+    Test.add_data_func ("/Unit/PurchaseChecker/SsoWebcallWrongPassword", test_authenticated_sso_webcall_wrong_password);
+    Test.add_data_func ("/Unit/PurchaseChecker/PurchaseDefaultPayment", test_purchase_with_default_payment);
+    Test.add_data_func ("/Unit/PurchaseChecker/PurchaseDefaultPaymentBroken", test_purchase_with_default_payment_broken_json);
+    Test.add_data_func ("/Unit/PurchaseChecker/PurchaseConnectionFails", test_purchase_with_default_payment_connection_fails);
+    Test.add_data_func ("/Unit/PurchaseChecker/PurchaseDefaultPaymentFails", test_purchase_with_default_payment_fails);
+
+    return Test.run ();
+  }
+
+  public static bool run_with_timeout (MainLoop ml, uint timeout_ms)
+  {
+    bool timeout_reached = false;
+    var t_id = Timeout.add (timeout_ms, () => {
+      timeout_reached = true;
+      debug ("Timeout reached");
+      ml.quit ();
+      return false;
+    });
+
+    ml.run ();
+
+    if (!timeout_reached) Source.remove (t_id);
+
+    return !timeout_reached;
+  }
+
+
+  async void irl_test_async ()
+  {
+    var purchase_service = new PurchaseService();
+    var purchase_sku = "1";
+    try {
+      yield purchase_service.fetch_payment_info (purchase_sku);
+      debug ("data was available: %s %s %s", purchase_service.nickname, purchase_service.email, purchase_service.selected_payment_method);
+      var real_user_password = "****fake_password_in_bzr***";
+      purchase_service.purchase (purchase_sku, real_user_password);
+      debug ("purchase completed.");
+    } catch (PurchaseError e) {
+      debug ("got purchase error: %s", e.message);
+    }
+  }
+
+  static void irl_test ()
+  {
+    var loop = new GLib.MainLoop ();
+    var m = new Main();
+    Idle.add (() => {
+      m.irl_test_async.begin ((obj, res) => {
+        m.irl_test_async.end (res);
+        loop.quit ();
+      });
+      return false;
+    });
+    assert (run_with_timeout (loop, 10000));
+  }
+
+  class FakeCredentialsManagement : GLib.Object, CredentialsManagement
+  {
+    private HashTable <string, string> fake_credentials;
+
+    construct
+    {
+      fake_credentials = new HashTable <string, string> (str_hash, str_equal);
+      fake_credentials["token"] = "fake_token";
+    }
+
+    public void find_credentials () throws IOError
+    {
+      Idle.add (() => {
+        credentials_found (fake_credentials);
+        return false;
+      });
+    }
+  }
+
+  class FailingCredentialsManagement : GLib.Object, CredentialsManagement
+  {
+    public void find_credentials () throws IOError
+    {
+      Idle.add (() => {
+        credentials_error ();
+        return false;
+      });
+    }
+  }
+
+  class ExtraFailingCredentialsManagement : GLib.Object, CredentialsManagement
+  {
+    public void find_credentials () throws IOError
+    {
+      throw new IOError.INVALID_DATA ("Miscellanea Errora");
+    }
+  }
+
+  class BaseTestPurchaseService : PurchaseService
+  {
+    internal override CredentialsManagement build_credentials_management ()
+    {
+      return new FakeCredentialsManagement ();
+    }
+  }
+
+  class FailingCredentialsPurchaseService : PurchaseService
+  {
+    internal override CredentialsManagement build_credentials_management ()
+    {
+      return new FailingCredentialsManagement ();
+    }
+  }
+
+  class ExtraFailingCredentialsPurchaseService : PurchaseService
+  {
+    internal override CredentialsManagement build_credentials_management ()
+    {
+      return new ExtraFailingCredentialsManagement ();
+    }
+  }
+
+  private static void test_parse_account ()
+  {
+    var purchase_service = new BaseTestPurchaseService ();
+    try {
+        purchase_service.parse_account_json (FAKE_JSON_ACCOUNT);
+    } catch (GLib.Error e)
+    {
+        assert_not_reached ();
+    }
+    assert_cmpstr (purchase_service.nickname, OperatorType.EQUAL, "Mr. Bean");
+    assert_cmpstr (purchase_service.email, OperatorType.EQUAL, "[e-mail]");
+  }
+
+  private static void test_parse_broken_account ()
+  {
+    var purchase_service = new BaseTestPurchaseService ();
+    try
+    {
+        purchase_service.parse_account_json (BROKEN_JSON);
+        assert_not_reached ();
+    } catch (GLib.Error e)
+    {
+        // This is *just* the error we are expecting, so do nothing!
+    }
+  }
+
+  private static void test_parse_payment_method ()
+  {
+    var purchase_service = new BaseTestPurchaseService ();
+    try
+    {
+        purchase_service.parse_payment_method_json (FAKE_JSON_PAYMENT_METHOD);
+    } catch (GLib.Error e)
+    {
+        assert_not_reached ();
+    }
+    assert_cmpstr (purchase_service.selected_payment_method, OperatorType.EQUAL, "Visa 1234");
+  }
+
+  private static void test_parse_authentication ()
+  {
+    var purchase_service = new BaseTestPurchaseService ();
+
+    try
+    {
+        purchase_service.parse_authentication_json (FAKE_JSON_AUTHENTICATION);
+    } catch (GLib.Error e)
+    {
+        assert_not_reached ();
+    }
+    assert_cmpstr (purchase_service.consumer_key, OperatorType.EQUAL, "fake_consumer_key");
+    assert_cmpstr (purchase_service.token, OperatorType.EQUAL, "fake_token");
+  }
+
+  private static void test_ready_to_purchase ()
+  {
+    var purchase_service = new BaseTestPurchaseService ();
+    assert (purchase_service.ready_to_purchase == false);
+    purchase_service.selected_payment_method = "visa 1234";
+    assert (purchase_service.ready_to_purchase == true);
+  }
+
+  class TestFetchPurchaseService : BaseTestPurchaseService {
+    internal bool fetch_called = false;
+    internal override async void refetch_payment_info (string purchase_sku)
+    {
+      fetch_called = true;
+    }
+  }
+
+  private static void test_fetch_payment_invalidated ()
+  {
+    var purchase_service = new TestFetchPurchaseService ();
+    purchase_service._selected_payment_method_expiry = new DateTime.now_utc ();
+    purchase_service.fetch_payment_info ("fake_sku");
+    assert (purchase_service.fetch_called);
+  }
+
+  private static void test_fetch_payment_cached ()
+  {
+    var purchase_service = new TestFetchPurchaseService ();
+    purchase_service._selected_payment_method_expiry = new DateTime.now_utc ().add_seconds (60);
+    purchase_service.fetch_payment_info ("fake_sku");
+    assert (purchase_service.fetch_called == false);
+  }
+
+  class TestRefetchPurchaseService : BaseTestPurchaseService {
+    internal bool credentials_fetched = false;
+    internal bool account_fetched = false;
+    internal bool payment_method_fetched = false;
+
+    internal override async void fetch_credentials ()
+    {
+      Idle.add (() => {
+        credentials_fetched = true;
+        fetch_credentials.callback ();
+        return false;
+      });
+      yield;
+    }
+    internal override async void fetch_account ()
+    {
+      Idle.add (() => {
+        account_fetched = true;
+        fetch_account.callback ();
+        return false;
+      });
+      yield;
+    }
+    internal override async void fetch_payment_method (string purchase_sku)
+    {
+      Idle.add (() => {
+        payment_method_fetched = true;
+        fetch_payment_method.callback ();
+        return false;
+      });
+      yield;
+    }
+  }
+
+  private static void test_refetch_payment ()
+  {
+    var purchase_service = new TestRefetchPurchaseService ();
+
+    MainLoop mainloop = new MainLoop ();
+    purchase_service.refetch_payment_info.begin("fake_sku", (obj, res) => {
+        mainloop.quit ();
+        try {
+            purchase_service.refetch_payment_info.end (res);
+        } catch (PurchaseError e) {
+            error ("Can't fetch payment info: %s", e.message);
+        }
+    });
+    assert (run_with_timeout (mainloop, 1000));
+
+    assert (purchase_service.credentials_fetched);
+    assert (purchase_service.account_fetched);
+    assert (purchase_service.payment_method_fetched);
+  }
+
+  private static void test_refetch_payment_sets_cache ()
+  {
+    var purchase_service = new TestRefetchPurchaseService ();
+
+    assert (true == purchase_service.expired_payment_method_cache ());
+
+    MainLoop mainloop = new MainLoop ();
+    purchase_service.refetch_payment_info.begin("fake_sku", (obj, res) => {
+        mainloop.quit ();
+        try {
+            purchase_service.refetch_payment_info.end (res);
+        } catch (PurchaseError e) {
+            error ("Can't fetch payment info: %s", e.message);
+        }
+    });
+    assert (run_with_timeout (mainloop, 1000));
+
+    assert (false == purchase_service.expired_payment_method_cache ());
+  }
+
+  private static void test_fetch_credentials ()
+  {
+    var purchase_service = new BaseTestPurchaseService ();
+
+    MainLoop mainloop = new MainLoop ();
+    purchase_service.fetch_credentials.begin((obj, res) => {
+        mainloop.quit ();
+        try {
+            purchase_service.fetch_credentials.end (res);
+        } catch (PurchaseError e) {
+            error ("Can't fetch credentials: %s", e.message);
+        }
+    });
+    assert (run_with_timeout (mainloop, 1000));
+
+    assert (purchase_service._ubuntuone_credentials != null);
+  }
+
+  private static void test_fetch_credentials_fails ()
+  {
+    bool failed = false;
+    var purchase_service = new FailingCredentialsPurchaseService ();
+
+    MainLoop mainloop = new MainLoop ();
+    purchase_service.fetch_credentials.begin((obj, res) => {
+        mainloop.quit ();
+        try {
+            purchase_service.fetch_credentials.end (res);
+        } catch (PurchaseError e) {
+            failed = true;
+        }
+    });
+    assert (run_with_timeout (mainloop, 1000));
+
+    assert (failed);
+  }
+
+  private static void test_fetch_credentials_fails_extra ()
+  {
+    bool failed = false;
+    var purchase_service = new ExtraFailingCredentialsPurchaseService ();
+
+    MainLoop mainloop = new MainLoop ();
+    purchase_service.fetch_credentials.begin((obj, res) => {
+        mainloop.quit ();
+        try {
+            purchase_service.fetch_credentials.end (res);
+        } catch (PurchaseError e) {
+            failed = true;
+        }
+    });
+    assert (run_with_timeout (mainloop, 1000));
+
+    assert (failed);
+  }
+
+  class FakeWebcallPurchaseService : BaseTestPurchaseService
+  {
+    internal string used_uri = null;
+    internal int status_code;
+    internal string found_json;
+
+    internal FakeWebcallPurchaseService (int _status_code, string _found_json) {
+        status_code = _status_code;
+        found_json = _found_json;
+    }
+
+    internal override async PurchaseError call_api (string method, string uri, out string response)
+    {
+        PurchaseError error = null;
+        Idle.add (() => {
+            call_api.callback ();
+            return false;
+        });
+        yield;
+        response = found_json;
+        if (status_code != Soup.KnownStatusCode.OK) {
+            error = new PurchaseError.PURCHASE_ERROR ("fake error");
+        }
+        return error;
+    }
+
+    internal override void _do_sso_webcall (Soup.Message message, string password)
+    {
+        message.response_body.append (Soup.MemoryUse.STATIC, found_json.data);
+        message.status_code = status_code;
+    }
+
+    internal override Soup.Message send_signed_webservice_call (string method, string uri)
+    {
+        var message = new Soup.Message (method, uri);
+        message.response_body.append (Soup.MemoryUse.STATIC, found_json.data);
+        message.status_code = status_code;
+        return message;
+    }
+  }
+
+  private static FakeWebcallPurchaseService _test_fetch_account (int _status_code, string _found_json) throws PurchaseError
+  {
+    var purchase_service = new FakeWebcallPurchaseService (_status_code, _found_json);
+    purchase_service._ubuntuone_credentials = new HashTable <string, string> (str_hash, str_equal);
+
+    PurchaseError error = null;
+    MainLoop mainloop = new MainLoop ();
+    purchase_service.fetch_account.begin((obj, res) => {
+        mainloop.quit ();
+        try {
+            purchase_service.fetch_account.end (res);
+        } catch (PurchaseError e) {
+            error = e;
+        }
+    });
+    assert (run_with_timeout (mainloop, 1000));
+    if (error != null) {
+        throw error;
+    }
+    return purchase_service;
+  }
+
+  private static void test_fetch_account ()
+  {
+    try {
+        var purchase_service = _test_fetch_account (Soup.KnownStatusCode.OK, FAKE_JSON_ACCOUNT);
+        assert_cmpstr (purchase_service.nickname, OperatorType.EQUAL, "Mr. Bean");
+        assert_cmpstr (purchase_service.email, OperatorType.EQUAL, "[e-mail]");
+    } catch (PurchaseError e) {
+        assert_not_reached ();
+    }
+  }
+
+  private static void test_fetch_account_http_failure ()
+  {
+    try {
+        _test_fetch_account (Soup.KnownStatusCode.INTERNAL_SERVER_ERROR, FAKE_JSON_ACCOUNT);
+        assert_not_reached ();
+    } catch (PurchaseError e) {
+        // Expected error
+    }
+  }
+
+  private static void test_fetch_account_wrong_json ()
+  {
+    try {
+        _test_fetch_account (Soup.KnownStatusCode.OK, BROKEN_JSON);
+        assert_not_reached ();
+    } catch (PurchaseError e) {
+        // Expected error
+    }
+  }
+
+  private static FakeWebcallPurchaseService _test_fetch_payment (int _status_code, string _found_json) throws PurchaseError
+  {
+    var purchase_service = new FakeWebcallPurchaseService (_status_code, _found_json);
+    purchase_service._ubuntuone_credentials = new HashTable <string, string> (str_hash, str_equal);
+
+    PurchaseError error = null;
+    MainLoop mainloop = new MainLoop ();
+    purchase_service.fetch_payment_method.begin("fake_sku", (obj, res) => {
+        mainloop.quit ();
+        try {
+            purchase_service.fetch_payment_method.end (res);
+        } catch (PurchaseError e) {
+            error = e;
+        }
+    });
+    assert (run_with_timeout (mainloop, 1000));
+    if (error != null) {
+        throw error;
+    }
+    return purchase_service;
+  }
+
+  private static void test_fetch_payment ()
+  {
+    try {
+        var purchase_service = _test_fetch_payment (Soup.KnownStatusCode.OK, FAKE_JSON_PAYMENT_METHOD);
+        assert_cmpstr (purchase_service.selected_payment_method, OperatorType.EQUAL, "Visa 1234");
+    } catch (PurchaseError e) {
+        assert_not_reached ();
+    }
+  }
+
+  private static void test_fetch_payment_http_failure ()
+  {
+    try {
+        _test_fetch_payment (Soup.KnownStatusCode.INTERNAL_SERVER_ERROR, FAKE_JSON_PAYMENT_METHOD);
+        assert_not_reached ();
+    } catch (PurchaseError e) {
+        // Expected error
+    }
+  }
+
+  private static void test_fetch_payment_wrong_json ()
+  {
+    try {
+        _test_fetch_payment (Soup.KnownStatusCode.OK, BROKEN_JSON);
+        assert_not_reached ();
+    } catch (PurchaseError e) {
+        // Expected error
+    }
+  }
+
+  class TestPurchaseService : BaseTestPurchaseService
+  {
+    internal string password;
+    internal string sku;
+    internal string purchase_token;
+
+    internal override string get_purchase_token (string password)
+    {
+        this.password = password;
+        return FAKE_TOKEN;
+    }
+    internal override void purchase_with_default_payment (string sku, string purchase_token)
+    {
+        this.sku = sku;
+        this.purchase_token = purchase_token;
+    }
+  }
+
+  private static void test_purchase ()
+  {
+    try {
+        var purchase_service = new TestPurchaseService ();
+        purchase_service.purchase (FAKE_SKU, FAKE_PASSWORD);
+        assert_cmpstr (purchase_service.password, OperatorType.EQUAL, FAKE_PASSWORD);
+        assert_cmpstr (purchase_service.sku, OperatorType.EQUAL, FAKE_SKU);
+        assert_cmpstr (purchase_service.purchase_token, OperatorType.EQUAL, FAKE_TOKEN);
+    } catch (Error e) {
+        assert_not_reached ();
+    }
+  }
+
+  class FakePurchaseTokenService : BaseTestPurchaseService
+  {
+    string found_json;
+
+    internal FakePurchaseTokenService (string _found_json)
+    {
+        found_json = _found_json;
+    }
+
+    internal override string authenticated_sso_webcall (string method, string uri, string operation, string password)
+        throws PurchaseError
+    {
+      return found_json;
+    }
+  }
+
+  private static void test_get_purchase_token ()
+  {
+    var purchase_service = new FakePurchaseTokenService (FAKE_JSON_AUTHENTICATION);
+    var expected = "fake_consumer_key:fake_token";
+    try {
+      var result = purchase_service.get_purchase_token (FAKE_PASSWORD);
+      assert_cmpstr (expected, OperatorType.EQUAL, result);
+    } catch (PurchaseError e) {
+      assert_not_reached ();
+    }
+  }
+
+  private static void test_get_purchase_token_broken_json ()
+  {
+    var purchase_service = new FakePurchaseTokenService (BROKEN_JSON);
+    try {
+      purchase_service.get_purchase_token (FAKE_PASSWORD);
+      assert_not_reached ();
+    } catch (PurchaseError e) {
+      assert (e is PurchaseError.PURCHASE_ERROR);
+    }
+  }
+
+  private static void test_authenticated_sso_webcall ()
+  {
+    var purchase_service = new FakeWebcallPurchaseService (Soup.KnownStatusCode.OK, FAKE_JSON_AUTHENTICATION);
+    try {
+      var result = purchase_service.authenticated_sso_webcall ("FAKE", "http://some/where", "operation=wolf", FAKE_PASSWORD);
+      assert_cmpstr (FAKE_JSON_AUTHENTICATION, OperatorType.EQUAL, result);
+    } catch (PurchaseError e) {
+      assert_not_reached ();
+    }
+  }
+
+  private static void test_authenticated_sso_webcall_fails ()
+  {
+    var purchase_service = new FakeWebcallPurchaseService (Soup.KnownStatusCode.INTERNAL_SERVER_ERROR, FAKE_JSON_AUTHENTICATION);
+    try {
+      purchase_service.authenticated_sso_webcall ("FAKE", "http://some/where", "operation=wolf", FAKE_PASSWORD);
+      assert_not_reached ();
+    } catch (Error e) {
+        assert (e is PurchaseError.PURCHASE_ERROR);
+    }
+  }
+
+  private static void test_authenticated_sso_webcall_wrong_password ()
+  {
+    var purchase_service = new FakeWebcallPurchaseService (Soup.KnownStatusCode.UNAUTHORIZED, FAKE_JSON_AUTHENTICATION);
+    try {
+      purchase_service.authenticated_sso_webcall ("FAKE", "http://some/where", "operation=wolf", FAKE_PASSWORD);
+      assert_not_reached ();
+    } catch (Error e) {
+        assert (e is PurchaseError.WRONG_PASSWORD_ERROR);
+    }
+  }
+
+  private static void test_purchase_with_default_payment ()
+  {
+    var purchase_service = new FakeWebcallPurchaseService (Soup.KnownStatusCode.OK, FAKE_JSON_PURCHASE);
+    try {
+      purchase_service.purchase_with_default_payment (FAKE_SKU, FAKE_TOKEN);
+    } catch (PurchaseError e) {
+      assert_not_reached ();
+    }
+  }
+
+  private static void test_purchase_with_default_payment_broken_json ()
+  {
+    var purchase_service = new FakeWebcallPurchaseService (Soup.KnownStatusCode.OK, BROKEN_JSON);
+    try {
+      purchase_service.purchase_with_default_payment (FAKE_SKU, FAKE_TOKEN);
+      assert_not_reached ();
+    } catch (PurchaseError e) {
+      assert (e is PurchaseError.PURCHASE_ERROR);
+    }
+  }
+
+  private static void test_purchase_with_default_payment_fails ()
+  {
+    var purchase_service = new FakeWebcallPurchaseService (Soup.KnownStatusCode.OK, FAKE_JSON_PURCHASE_FAILURE);
+    try {
+      purchase_service.purchase_with_default_payment (FAKE_SKU, FAKE_TOKEN);
+      assert_not_reached ();
+    } catch (PurchaseError e) {
+      assert (e is PurchaseError.PURCHASE_ERROR);
+    }
+  }
+
+  private static void test_purchase_with_default_payment_connection_fails ()
+  {
+    var purchase_service = new FakeWebcallPurchaseService (Soup.KnownStatusCode.INTERNAL_SERVER_ERROR, FAKE_JSON_PURCHASE_FAILURE);
+    try {
+      purchase_service.purchase_with_default_payment (FAKE_SKU, FAKE_TOKEN);
+      assert_not_reached ();
+    } catch (PurchaseError e) {
+      assert (e is PurchaseError.PURCHASE_ERROR);
+    }
+  }
+}