diff --git a/README.md b/README.md
index 2c56cb07..9142696d 100644
--- a/README.md
+++ b/README.md
@@ -4,15 +4,15 @@ JavaScript client for the openEO API.
 
 [![Build Status](https://travis-ci.org/Open-EO/openeo-js-client.svg?branch=master)](https://travis-ci.org/Open-EO/openeo-js-client)
 
-This client is in **version 0.3.1** and supports **openEO API versions 0.3.0 and 0.3.1**. Legacy versions are available as releases.
+This client is in **version 0.3.2** and supports **openEO API versions 0.3.0 and 0.3.1**. Legacy versions are available as releases.
 
 ## Usage
 This library can run in a recent browser supporting ECMAScript 2015 or node.js.
 
 To use it in a browser environment simply add the following code to your HTML file:
 ```
-<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
-<script src="https://unpkg.com/@openeo/js-client/openeo.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/@openeo/js-client/openeo.js"></script>
 ```
 
 To install it with npm: `npm install @openeo/js-client`
diff --git a/examples/discovery.html b/examples/discovery.html
index dd22fd1c..fabbf907 100644
--- a/examples/discovery.html
+++ b/examples/discovery.html
@@ -4,7 +4,7 @@
         <title>openEO JS client - Discovery example</title>
         <meta charset="UTF-8">
         <meta name="viewport" content="width=device-width, initial-scale=1.0">
-		<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
+		<script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
 		<script src="../openeo.js"></script>
 		<script type="text/javascript">
 			var url = "https://earthengine.openeo.org/v0.3"; // Insert the openEO server URL here
diff --git a/openeo.js b/openeo.js
index 31f19789..22541083 100644
--- a/openeo.js
+++ b/openeo.js
@@ -35,7 +35,7 @@ class OpenEO {
 	}
 
 	version() {
-		return "0.3.0";
+		return "0.3.2";
 	}
 }
 
@@ -94,6 +94,21 @@ class Connection {
 			.then(response => response.data);
 	}
 
+	buildProcessGraph() {
+		return this.listProcesses()
+			.then(data => {
+				var builder = {};
+				for(let i in data.processes) {
+					let process = data.processes[i];
+					builder[process.name] = (options) => {
+						options.process_id = process.name;
+						return options;
+					}
+				}
+				return builder;
+			});
+	}
+
 	authenticateOIDC(options = null) {
 		return Promise.reject(new Error("Not implemented yet."));
 	}
@@ -204,7 +219,7 @@ class Connection {
 	}
 
 	createJob(processGraph, outputFormat = null, outputParameters = {}, title = null, description = null, plan = null, budget = null, additional = {}) {
-		var jobObject = Object.assign(additional, {
+		var jobObject = Object.assign({}, additional, {
 			title: title,
 			description: description,
 			process_graph: processGraph,
@@ -328,7 +343,48 @@ class Connection {
 				break;
 		}
 
-		return axios(options);
+		return axios(options).catch(error => {
+			return new Promise((resolve, reject) => {
+				if (error.response !== null && typeof error.response === 'object' && error.response.data !== null && typeof error.response.data === 'object' && typeof error.response.data.type === 'string' && error.response.data.type.indexOf('/json') !== -1) {
+					// JSON error responses are Blobs and streams if responseType is set as such, so convert to JSON if required.
+					// See: https://github.com/axios/axios/issues/815
+					try {
+						switch(options.responseType) {
+							case 'blob':
+								const fileReader = new FileReader();
+								fileReader.onerror = () => {
+									fileReader.abort();
+									reject(error);
+								};
+								fileReader.onload = () => {
+									reject(JSON.parse(fileReader.result));
+								};
+								fileReader.readAsText(error.response.data);
+								break;
+							case 'stream':
+								const chunks = "";
+								error.response.data.on("data", chunk => {
+									chunks.push(chunk);
+								});
+								readStream.on("error", () =>  {
+									reject(error);
+								});
+								readStream.on("end", () => {
+									reject(JSON.parse(Buffer.concat(chunks).toString()));
+								});
+								break;
+							default:
+								reject(error);
+						}
+					} catch (exception) {
+						reject(error);
+					}
+				}
+				else {
+					reject(error);
+				}
+			});
+		});
 	}
 
 	_resetAuth() {
@@ -498,7 +554,7 @@ class Subscriptions {
 
 	_flushQueue() {
 		if(this.socket.readyState === this.socket.OPEN) {
-			for(var i in this.messageQueue) {
+			for(let i in this.messageQueue) {
 				this.socket.send(JSON.stringify(this.messageQueue[i]));
 			}
 
@@ -538,7 +594,7 @@ class Subscriptions {
 			parameters = {};
 		}
 
-		var payloadParameters = Object.assign(parameters, { topic: topic });
+		var payloadParameters = Object.assign({}, parameters, { topic: topic });
 
 		this._sendMessage(action, {
 			topics: [payloadParameters]
@@ -553,15 +609,19 @@ class Capabilities {
 		if(!data || !data.version || !data.endpoints) {
 			throw new Error("Data is not a valid Capabilities response");
 		}
-		this._data = data;
+		this.data = data;
+	}
+
+	toPlainObject() {
+		return this.data;
 	}
 
 	version() {
-		return this._data.version;
+		return this.data.version;
 	}
 
 	listFeatures() {
-		return this._data.endpoints;
+		return this.data.endpoints;
 	}
 
 	hasFeature(methodName) {
@@ -606,14 +666,14 @@ class Capabilities {
 		};
 		
 		// regex-ify to allow custom parameter names
-		for (var key in clientMethodNameToAPIRequestMap) {
+		for(let key in clientMethodNameToAPIRequestMap) {
 			clientMethodNameToAPIRequestMap[key] = clientMethodNameToAPIRequestMap[key].replace(/{[^}]+}/, '{[^}]+}');
 		}
 
 		if (methodName === 'createFile') {
 			return this.hasFeature('uploadFile'); // createFile is always available, map it to uploadFile as it is more meaningful.
 		} else {
-			return this._data.endpoints
+			return this.data.endpoints
 				.map((e) => e.methods.map((method) => method + ' ' + e.path))
 				// .flat(1)   // does exactly what we want, but (as of Sept. 2018) not yet part of the standard...
 				.reduce((a, b) => a.concat(b), [])  // ES6-proof version of flat(1)
@@ -622,11 +682,11 @@ class Capabilities {
 	}
 
 	currency() {
-		return (this._data.billing ? this._data.billing.currency : null);
+		return (this.data.billing ? this.data.billing.currency : null);
 	}
 
 	listPlans() {
-		return (this._data.billing ? this._data.billing.plans : null);
+		return (this.data.billing ? this.data.billing.plans : null);
 	}
 }
 
@@ -637,8 +697,8 @@ class BaseEntity {
 		this.connection = connection;
 		this.clientNames = {};
 		this.extra = {};
-		for(var i in properties) {
-			var backend, client;
+		for(let i in properties) {
+			let backend, client;
 			if (Array.isArray(properties[i])) {
 				backend = properties[i][0];
 				client = properties[i][1];
@@ -655,7 +715,7 @@ class BaseEntity {
 	}
 
 	setAll(metadata) {
-		for (var name in metadata) {
+		for(let name in metadata) {
 			if (typeof this.clientNames[name] === 'undefined') {
 				this.extra[name] = metadata[name];
 			}
@@ -668,8 +728,8 @@ class BaseEntity {
 
 	getAll() {
 		var obj = {};
-		for (var backend in this.clientNames) {
-			var client = this.clientNames[backend];
+		for(let backend in this.clientNames) {
+			let client = this.clientNames[backend];
 			obj[client] = this[client];
 		}
 		return Object.assign(obj, this.extra);
@@ -736,7 +796,7 @@ class File extends BaseEntity {
 			}
 		};
 		if (typeof statusCallback === 'function') {
-			options.onUploadProgress = function(progressEvent) {
+			options.onUploadProgress = (progressEvent) => {
 				var percentCompleted = Math.round( (progressEvent.loaded * 100) / progressEvent.total );
 				statusCallback(percentCompleted);
 			};
@@ -836,11 +896,11 @@ class Job extends BaseEntity {
 
 				var promises = [];
 				var files = [];
-				for(var i in list.links) {
-					var link = list.links[i].href;
-					var parsedUrl = url.parse(link);
-					var targetPath = path.join(targetFolder, path.basename(parsedUrl.pathname));
-					var p = this.connection.download(link, false)
+				for(let i in list.links) {
+					let link = list.links[i].href;
+					let parsedUrl = url.parse(link);
+					let targetPath = path.join(targetFolder, path.basename(parsedUrl.pathname));
+					let p = this.connection.download(link, false)
 						.then(response => this.connection._saveToFileNode(response.data, targetPath))
 						.then(() => files.push(targetPath));
 					promises.push(p);
@@ -926,13 +986,14 @@ if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
 	module.exports = toExport;
 }
 else {
+	/* istanbul ignore next */
 	if (typeof define === 'function' && define.amd) {
 		define([], function () {
 			return toExport;
 		});
 	}
 	else {
-		for (let exportObjName in toExport) {
+		for(let exportObjName in toExport) {
 			window[exportObjName] = toExport[exportObjName];
 		}
 	}
diff --git a/package.json b/package.json
index 18e964b6..3038107f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@openeo/js-client",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "author": "openEO Consortium",
   "contributors": [
     {
@@ -30,7 +30,8 @@
     "ws": "^6.1.2"
   },
   "scripts": {
-    "test": "jest --env=jsdom",
-    "test_node": "jest --env=node"
+    "test": "jest basic.test.js --env=jsdom",
+    "test_node": "jest basic.test.js --env=node",
+    "test_gee": "jest earthengine.test.js --env=node"
   }
 }
diff --git a/tests/basic.test.js b/tests/basic.test.js
index 8d0f0182..a54a72e1 100644
--- a/tests/basic.test.js
+++ b/tests/basic.test.js
@@ -1,12 +1,13 @@
 const { OpenEO } = require('../openeo.js');
+const packageInfo = require('../package.json');
 
-describe('Check version number', () => {
+describe('Basic client tests', () => {
 	var obj = new OpenEO();
 	test('Check that import worked', () => {
 		expect(obj).not.toBeNull();
 		expect(obj).toBeInstanceOf(OpenEO);
 	});
 	test('Check version number', () => {
-		expect(obj.version()).toBe("0.3.0");
+		expect(obj.version()).toBe(packageInfo.version);
 	});
 });
\ No newline at end of file
diff --git a/tests/earthengine.test.js b/tests/earthengine.test.js
new file mode 100644
index 00000000..e205bc7a
--- /dev/null
+++ b/tests/earthengine.test.js
@@ -0,0 +1,698 @@
+const { OpenEO } = require('../openeo.js');
+
+jest.setTimeout(30000); // Give Google some time to process data
+
+describe('With earth-engine-driver', () => {
+	const TESTBACKEND = 'http://earthengine.openeo.org/v0.3';
+	const TESTUSERNAME = 'group5';
+	const TESTPASSWORD = 'test123';
+	const TESTCAPABILITIES = {"version":"0.3.1","endpoints":[{"path":"/","methods":["GET"]},{"path":"/service_types","methods":["GET"]},{"path":"/output_formats","methods":["GET"]},{"path":"/stac","methods":["GET"]},{"path":"/collections","methods":["GET"]},{"path":"/collections/{collection_id}","methods":["GET"]},{"path":"/processes","methods":["GET"]},{"path":"/files/{user_id}","methods":["GET"]},{"path":"/files/{user_id}/{path}","methods":["GET","PUT","DELETE"]},{"path":"/preview","methods":["POST"]},{"path":"/jobs","methods":["POST","GET"]},{"path":"/jobs/{job_id}","methods":["GET","PATCH","DELETE"]},{"path":"/jobs/{job_id}/results","methods":["GET","POST","DELETE"]},{"path":"/temp/{token}/{file}","methods":["GET"]},{"path":"/services","methods":["GET","POST"]},{"path":"/services/{service_id}","methods":["GET","PATCH","DELETE"]},{"path":"/xyz/{service_id}/{z}/{x}/{y}","methods":["GET"]},{"path":"/subscription","methods":["GET"]},{"path":"/credentials/basic","methods":["GET"]},{"path":"/credentials","methods":["POST"]},{"path":"/me","methods":["GET"]},{"path":"/validation","methods":["POST"]},{"path":"/process_graphs","methods":["GET","POST"]},{"path":"/process_graphs/{process_graph_id}","methods":["GET","PATCH","DELETE"]}],"billing":{"currency":"USD","default_plan":"free","plans":[{"name":"free","description":"Earth Engine is free for research, education, and nonprofit use. For commercial applications, Google offers paid commercial licenses. Please contact earthengine-commercial@google.com for details."}]}};
+	const TESTCOLLECTION = {"name":"USGS/GTOPO30","title":"GTOPO30: Global 30 Arc-Second Elevation","description":"GTOPO30 is a global digital elevation model (DEM) with a horizontal grid spacing of 30 arc seconds (approximately 1 kilometer). The DEM was derived from several raster and vector sources of topographic information.  Completed in late 1996, GTOPO30 was developed over a three-year period through a collaborative effort led by the U.S. Geological Survey's Center for Earth Resources Observation and Science (EROS). The following organizations  participated by contributing funding or source data:  the National Aeronautics  and Space Administration (NASA), the United Nations Environment Programme/Global Resource Information Database (UNEP/GRID), the U.S. Agency for International Development (USAID), the Instituto Nacional de Estadistica Geografica e Informatica (INEGI) of Mexico, the Geographical Survey Institute  (GSI) of Japan, Manaaki Whenua Landcare Research of New Zealand, and the  Scientific Committee on Antarctic Research (SCAR).","license":"proprietary","extent":{"spatial":[-180,-90,180,90],"temporal":["1996-01-01T00:00:00Z","1996-01-01T00:00:00Z"]}};
+	const TESTPROCESS = {"name":"count_time","description":"Counts the number of images with a valid mask in a time series for all bands of the input dataset.","parameters":{"imagery":{"description":"EO data to process.","required":true,"schema":{"type":"object","format":"eodata"}}},"returns":{"description":"Processed EO data.","schema":{"type":"object","format":"eodata"}}};
+	const TESTPROCESSGGRAPH = {"process_id":"stretch_colors","imagery":{"process_id":"min_time","imagery":{"process_id":"NDVI","imagery":{"process_id":"filter_bbox","imagery":{"process_id":"filter_daterange","imagery":{"process_id":"get_collection","name":"COPERNICUS/S2"},"extent":["2018-01-01T00:00:00Z","2018-01-31T23:59:59Z"]},"extent":{"west":16.1,"south":47.2,"east":16.6,"north":48.6}},"red":"B4","nir":"B8"}},"min":-1,"max":1};
+	var obj = new OpenEO();
+	var isBrowserEnv = (typeof Blob !== 'undefined');
+
+	async function connectWithoutAuth() {
+		return obj.connect(TESTBACKEND);
+	}
+
+	async function connectWithBasicAuth() {
+		return obj.connect(TESTBACKEND, 'basic', {username: TESTUSERNAME, password: TESTPASSWORD});
+	}
+
+	describe('Connecting', () => {
+		test('Connect without credentials', async () => {
+			await connectWithoutAuth().then(async con => {
+				expect(con).not.toBeNull();
+				expect(Object.getPrototypeOf(con).constructor.name).toBe('Connection');
+				expect(con.isLoggedIn()).toBeFalsy();
+				expect(con.getUserId()).toBeNull();
+				expect(con.getBaseUrl()).toBe(TESTBACKEND);
+			});
+		});
+
+		test('Connect with Basic Auth credentials', async () => {
+			await connectWithBasicAuth().then(con => {
+				expect(con).not.toBeNull();
+				expect(Object.getPrototypeOf(con).constructor.name).toBe('Connection');
+				expect(con.isLoggedIn()).toBeTruthy();
+				expect(con.getUserId()).toBe(TESTUSERNAME);
+				expect(con.getBaseUrl()).toBe(TESTBACKEND);
+			});
+		});
+
+		test('Connect with wrong Server URL', async () => {
+			await expect(obj.connect("http://localhost:12345")).rejects.toThrow();
+		});
+
+		test('Connect with wrong Basic Auth credentials', async () => {
+			await expect(obj.connect(TESTBACKEND, 'basic', {username: "foo", password: "bar"})).rejects.toThrow();
+		});
+
+		test('Manually connect with Basic Auth credentials', async () => {
+			await connectWithoutAuth().then(async con => {
+				expect(con).not.toBeNull();
+				expect(Object.getPrototypeOf(con).constructor.name).toBe('Connection');
+				expect(con.isLoggedIn()).toBeFalsy();
+				expect(con.getUserId()).toBeNull();
+				var login = await con.authenticateBasic(TESTUSERNAME, TESTPASSWORD);
+				expect(con.isLoggedIn()).toBeTruthy();
+				expect(con.getUserId()).toBe(TESTUSERNAME);
+				expect(con.getBaseUrl()).toBe(TESTBACKEND);
+				expect(login).toHaveProperty('user_id');
+				expect(login).toHaveProperty('access_token');
+			});
+		});
+
+		test('Auth via OIDC is not implemented yet', async () => {
+			await connectWithoutAuth().then(async con => {
+				expect(con).not.toBeNull();
+				expect(Object.getPrototypeOf(con).constructor.name).toBe('Connection');
+				expect(con.isLoggedIn()).toBeFalsy();
+				expect(con.getUserId()).toBeNull();
+				expect(con.getBaseUrl()).toBe(TESTBACKEND);
+				expect(con.authenticateOIDC({})).rejects.toThrow(new Error('Not implemented yet.'));
+			});
+		});
+
+		test('Manually connect with wrong Basic Auth credentials', async () => {
+			await connectWithoutAuth().then(async con => {
+				expect(con).not.toBeNull();
+				expect(Object.getPrototypeOf(con).constructor.name).toBe('Connection');
+				expect(con.isLoggedIn()).toBeFalsy();
+				expect(con.getUserId()).toBeNull();
+				await expect(con.authenticateBasic("foo", "bar")).rejects.toThrow();
+				expect(con.isLoggedIn()).toBeFalsy();
+				expect(con.getUserId()).toBeNull();
+				expect(con.getBaseUrl()).toBe(TESTBACKEND);
+			});
+		});
+
+		test('Connect via OIDC is not implemented yet', async () => {
+			await expect(obj.connect(TESTBACKEND, 'oidc', {})).rejects.toThrow(new Error('Not implemented yet.'));
+		});
+
+		test('Connect via unknown should throw an error', async () => {
+			await expect(obj.connect(TESTBACKEND, 'unknown', {})).rejects.toThrow(new Error("Unknown authentication type."));
+		});
+	});
+	
+	describe('Discovery', () => {
+		var con;
+		beforeAll(async (done) => {
+			con = await connectWithoutAuth();
+			done();
+		});
+		
+		test('Capabilities', async () => {
+			var caps = await con.capabilities();
+			expect(caps).not.toBeNull();
+			expect(Object.getPrototypeOf(caps).constructor.name).toBe('Capabilities');
+			expect(caps._data).toEqual(TESTCAPABILITIES);
+			expect(caps.version()).toBe('0.3.1');
+			expect(caps.listFeatures()).toEqual(TESTCAPABILITIES.endpoints);
+			expect(caps.listPlans()).toEqual(TESTCAPABILITIES.billing.plans);
+			expect(caps.currency()).toEqual(TESTCAPABILITIES.billing.currency);
+			expect(caps.hasFeature('startJob')).toBeTruthy();
+			expect(caps.hasFeature('createFile')).toBeTruthy();
+			expect(caps.hasFeature('somethingThatIsntSupported')).toBeFalsy();
+		});
+
+		test('Collections', async () => {
+			var colls = await con.listCollections();
+			expect(colls).not.toBeNull();
+			expect(colls).toHaveProperty('collections');
+			expect(colls).toHaveProperty('links');
+			expect(Array.isArray(colls.collections)).toBe(true);
+			expect(colls.collections.length).toBeGreaterThan(100);
+			expect(colls.collections[0]).toHaveProperty("description");
+			expect(colls.collections[0]).toHaveProperty("license");
+			expect(colls.collections[0]).toHaveProperty("extent");
+			expect(colls.collections[0]).toHaveProperty("links");
+		});
+
+		test('Collections in detail', async () => {
+			var coll = await con.describeCollection(TESTCOLLECTION.name);
+			expect(coll).not.toBeNull();
+			expect(coll).toHaveProperty('description');
+			expect(coll).toHaveProperty('license');
+			expect(coll).toHaveProperty('extent');
+			expect(coll).toHaveProperty('links');
+			expect(coll.name).toBe(TESTCOLLECTION.name);
+		});
+
+		test('Processes', async () => {
+			var procs = await con.listProcesses();
+			expect(procs).not.toBeNull();
+			expect(procs).toHaveProperty('processes');
+			expect(procs.processes.length).toBeGreaterThan(10);
+			expect(procs.processes).toContainEqual(TESTPROCESS);
+		});
+
+		test('File types', async () => {
+			var types = await con.listFileTypes();
+			expect(types).not.toBeNull();
+			expect(types).toHaveProperty('default');
+			expect(types).toHaveProperty('formats');
+			expect(types.formats).toHaveProperty('PNG');
+		});
+
+		test('Service types', async () => {
+			var types = await con.listServiceTypes();
+			expect(types).not.toBeNull();
+			expect(types).toHaveProperty('xyz');
+		});
+	});
+
+	describe('Getting user-specific data', async () => {
+		var con;
+		beforeAll(async (done) => {
+			con = await connectWithBasicAuth();
+			done();
+		});
+
+		test('Describe account', async () => {
+			var acc = await con.describeAccount();
+			expect(acc).not.toBeNull();
+			expect(acc.user_id).toBe(TESTUSERNAME);
+		});
+	});
+
+	describe('Process graph validation', async () => {
+		var con;
+		beforeAll(async (done) => {
+			con = await connectWithBasicAuth();
+			done();
+		});
+
+		test('Valid process graph', async () => {
+			var result = await con.validateProcessGraph({
+				process_id: "get_collection",
+				name: "COPERNICUS/S2"
+			});
+			expect(result[0]).toBeTruthy();
+			expect(result[1]).toEqual({});
+		});
+
+		test('Invalid process graph', async () => {
+			var result = await con.validateProcessGraph({
+				process_id: "unknown_process"
+			});
+			expect(result[0]).toBeFalsy();
+			expect(typeof result[1]).toBe('object');
+			expect(result[1]).toHaveProperty('code');
+			expect(result[1]).toHaveProperty('message');
+		});
+	});
+
+	describe('Stored process graphs management', async () => {
+		var con;
+		beforeAll(async () => {
+			con = await connectWithBasicAuth();
+			// clean up
+			var list = await con.listProcessGraphs();
+			await Promise.all(list.map(pg => pg.deleteProcessGraph()));
+		});
+
+		test('List process graphs', async () => {
+			var pgs = await con.listProcessGraphs();
+			expect(pgs).not.toBeNull();
+			expect(pgs).toHaveLength(0);
+		});
+
+		var pg1;
+		var pg2;
+		test('Add process graph without metadata', async () => {
+			var pg = await con.createProcessGraph(TESTPROCESSGGRAPH);
+			expect(pg).not.toBeNull();
+			expect(pg).not.toBeUndefined();
+			expect(Object.getPrototypeOf(pg).constructor.name).toBe('ProcessGraph');
+			expect(pg.connection).toBe(con);
+			expect(pg.processGraphId).not.toBeNull();
+			expect(pg.processGraphId).not.toBeUndefined();
+			expect(pg.title).toBeNull();
+			expect(pg.description).toBeNull();
+			expect(pg.processGraph).toEqual(TESTPROCESSGGRAPH);
+			pg1 = pg;
+		});
+
+		test('Make sure there is now 1 process graph, with no metadata', async () => {
+			var pgs = await con.listProcessGraphs();
+			expect(pgs).toHaveLength(1);
+			expect(pgs[0]).not.toBeNull();
+			expect(pgs[0]).not.toBeUndefined();
+			expect(Object.getPrototypeOf(pgs[0]).constructor.name).toBe('ProcessGraph');
+			expect(pgs[0].processGraphId).not.toBeNull();
+			expect(pgs[0].processGraphId).toBe(pg1.processGraphId);
+			expect(pgs[0].title).toBeNull();
+			expect(pgs[0].description).toBeNull();
+		});
+
+		test('Add process graph with metadata', async () => {
+			var pg = await con.createProcessGraph(TESTPROCESSGGRAPH, 'Test title', 'Test description');
+			expect(pg).not.toBeNull();
+			expect(pg).not.toBeUndefined();
+			expect(Object.getPrototypeOf(pg).constructor.name).toBe('ProcessGraph');
+			expect(pg.connection).toBe(con);
+			expect(pg.processGraphId).not.toBeNull();
+			expect(pg.processGraphId).not.toBe(pg1.processGraphId);
+			expect(pg.title).toBe('Test title');
+			expect(pg.description).toBe('Test description');
+			expect(pg.processGraph).toEqual(TESTPROCESSGGRAPH);
+			pg2 = pg;
+		});
+
+		test('Make sure there are now 2 process graphs, the second with metadata', async () => {
+			var pgs = await con.listProcessGraphs();
+			expect(pgs).toHaveLength(2);
+			var pg = (pgs[0].processGraphId != pg1.processGraphId ? pgs[0] : pgs[1]);
+			expect(pg).not.toBeNull();
+			expect(pg).not.toBeUndefined();
+			expect(Object.getPrototypeOf(pg).constructor.name).toBe('ProcessGraph');
+			expect(pg.processGraphId).not.toBeNull();
+			expect(pg.processGraphId).not.toBe(pg1.processGraphId);
+			expect(pg.processGraphId).toBe(pg2.processGraphId);
+			expect(pg.title).toBe('Test title')
+			expect(pg.description).toBe('Test description');
+			
+		});
+
+		test('Describe process graph without metadata', async () => {
+			var pg = await pg1.describeProcessGraph();
+			expect(pg).not.toBeNull();
+			expect(pg).not.toBeUndefined();
+			expect(pg.processGraphId).not.toBeNull();
+			expect(pg.processGraphId).toBe(pg1.processGraphId);
+			expect(pg.title).toBeNull();
+			expect(pg.description).toBeNull();
+		});
+
+		test('Describe process graph with metadata', async () => {
+			var pg = await pg2.describeProcessGraph();
+			expect(pg).not.toBeNull();
+			expect(pg).not.toBeUndefined();
+			expect(pg.processGraphId).not.toBeNull();
+			expect(pg.processGraphId).toBe(pg2.processGraphId);
+			expect(pg.title).toBe('Test title');
+			expect(pg.description).toBe('Test description');
+		});
+
+		test('Update process graph', async () => {
+			await pg1.updateProcessGraph({title: 'Test title 2'});
+			var pg = await pg1.describeProcessGraph();
+			expect(pg).not.toBeNull();
+			expect(pg).not.toBeUndefined();
+			expect(pg.processGraphId).not.toBeNull();
+			expect(pg.processGraphId).toBe(pg1.processGraphId);
+			expect(pg.title).toBe('Test title 2');
+			expect(pg.description).toBeNull();
+		});
+
+		test('Delete the second process graph', async () => {
+			const success = await pg2.deleteProcessGraph();
+			expect(success).toBeTruthy();
+			
+			var pgs = await con.listProcessGraphs();
+			expect(pgs).toHaveLength(1);
+			expect(pgs[0].processGraphId).toBe(pg1.processGraphId);
+		});
+	});
+
+	describe('Previews', async () => {
+		var con;
+		beforeAll(async () => {
+			con = await connectWithBasicAuth();
+			// clean up
+			var list = await con.listJobs();
+			await Promise.all(list.map(j => j.deleteJob()));
+		});
+
+		test('Preview a process graph result', async () => {
+			var resource = await con.execute(TESTPROCESSGGRAPH, 'jpeg');
+			expect(resource).not.toBeNull();
+			if (isBrowserEnv) { // Browser environment
+				expect(resource).toBeInstanceOf(Blob);
+				// ToDo: Check blob content
+			}
+			else { // Node environment
+				const stream = require('stream');
+				expect(resource).toBeInstanceOf(stream.Readable);
+				// ToDo: Check blob content
+			}
+		});
+	});
+
+	describe('Job management', async () => {
+		var con;
+		beforeAll(async () => {
+			con = await connectWithBasicAuth();
+			// clean up
+			var list = await con.listJobs();
+			await Promise.all(list.map(j => j.deleteJob()));
+		});
+
+		test('List jobs in general', async () => {
+			var jobs = await con.listJobs();
+			expect(jobs).not.toBeNull();
+			expect(jobs).toHaveLength(0);
+		});
+
+		var job;
+		test('Add minimal job', async () => {
+			job = await con.createJob(TESTPROCESSGGRAPH, 'jpeg');
+			expect(Object.getPrototypeOf(job).constructor.name).toBe('Job');
+			expect(job.jobId).not.toBeNull();
+			expect(job.jobId).not.toBeUndefined();
+			var jobs = await con.listJobs();
+			expect(jobs).toHaveLength(1);
+			expect(Object.getPrototypeOf(jobs[0]).constructor.name).toBe('Job');
+			expect(jobs[0].jobId).toBe(job.jobId);
+		});
+
+		test('Describe job', async () => {
+			var jobdetails = await job.describeJob();
+			expect(jobdetails).not.toBeNull();
+			expect(jobdetails).not.toBeUndefined();
+			expect(jobdetails.jobId).toBe(job.jobId);
+			expect(jobdetails.title).toBeNull();
+			expect(jobdetails.status).toBe('submitted');
+			expect(typeof jobdetails.submitted).toBe('string');
+		});
+
+		test('Update job', async () => {
+			var success = await job.updateJob({title: 'Test job'});
+			expect(success).toBeTruthy();
+			var jobdetails = await job.describeJob();
+			expect(jobdetails).not.toBeNull();
+			expect(jobdetails).not.toBeUndefined();
+			expect(jobdetails.jobId).toBe(job.jobId);
+			expect(jobdetails.title).toBe('Test job');
+			expect(typeof jobdetails.submitted).toBe('string');
+		});
+
+		test('Estimate job', async () => {
+			// Not implemented by GEE back-end
+			await expect(job.estimateJob()).rejects.toThrow();
+		});
+
+		// Starting, Stopping, and working with results as implemented here only works as GEE computes on the fly.
+		// Other back-ends need more time and therefore we would need to wait here until the started job finished.
+		// Also, stopping jobs may discard results and therefore working with the results may fail.
+		test('Start job', async () => {
+			await expect(job.startJob()).resolves.toBeTruthy();
+			var jobdetails = await job.describeJob();
+			expect(jobdetails.status).toBe('finished');
+		});
+
+		test('List metalink Results', async () => {
+			var jobdetails = await job.describeJob();
+			expect(jobdetails.status).toBe('finished');
+			await expect(job.listResults("metalink")).rejects.toThrow();
+		});
+
+		test('List json Results', async () => {
+			var jobdetails = await job.describeJob();
+			expect(jobdetails.status).toBe('finished');
+			var res = await job.listResults();
+			expect(res).not.toBeNull();
+			expect(res).toHaveProperty("costs");
+			expect(res).toHaveProperty("expires");
+			expect(res).toHaveProperty("links");
+			expect(res.links.length).toBeGreaterThan(0);
+			expect(res.links[0]).toHaveProperty("href");
+		});
+
+		var targetFolder = Math.random().toString(36);
+		test('Download results', async () => {
+			var jobdetails = await job.describeJob();
+			expect(jobdetails.status).toBe('finished');
+			if (isBrowserEnv) {
+				// Browser environment
+				await expect(job.downloadResults()).rejects.toThrow();
+			}
+			else {
+				// Node environment
+				// Create folder
+				const fs = require('fs');
+				expect(fs.existsSync(targetFolder)).toBeFalsy();
+				fs.mkdirSync(targetFolder);
+				expect(fs.existsSync(targetFolder)).toBeTruthy();
+				// Get links to check against
+				var res = await job.listResults();
+				expect(res).not.toBeNull();
+				expect(res).toHaveProperty("links");
+				expect(res.links.length).toBeGreaterThan(0);
+				// Download files
+				var files = await job.downloadResults(targetFolder);
+				expect(files.length).toBe(res.links.length);
+				for(var i in files) {
+					expect(fs.existsSync(files[i])).toBeTruthy();
+				}
+			}
+		});
+
+		test('Stop job', async () => {
+			await expect(job.stopJob()).resolves.toBeTruthy();
+			var jobdetails = await job.describeJob();
+			expect(jobdetails.status).toBe('canceled');
+		});
+
+		test('Delete job', async () => {
+			var success = await job.deleteJob();
+			expect(success).toBeTruthy();
+			var jobs = await con.listJobs();
+			expect(jobs).toHaveLength(0);
+		});
+
+		afterAll(async () => {
+			if (!isBrowserEnv) {
+				// clean up
+				const fs = require('fs');
+				const path = require('path');
+				var files = fs.readdirSync(targetFolder);
+				files.map(file => {
+					fs.unlinkSync(path.join(targetFolder, file));
+				});
+				fs.unlinkSync(targetFolder);
+			}
+		});
+	});
+
+	describe('Secondary Services management', async () => {
+		var con;
+		beforeAll(async () => {
+			con = await connectWithBasicAuth();
+			// clean up
+			var list = await con.listServices();
+			await Promise.all(list.map(s => s.deleteService()));
+		});
+
+		test('List services in general', async () => {
+			var svcs = await con.listServices();
+			expect(svcs).not.toBeNull();
+			expect(svcs).toHaveLength(0);
+		});
+
+		var svc;
+		test('Add minimal service', async () => {
+			svc = await con.createService(TESTPROCESSGGRAPH, 'xyz');
+			expect(Object.getPrototypeOf(svc).constructor.name).toBe('Service');
+			expect(svc.serviceId).not.toBeNull();
+			expect(svc.serviceId).not.toBeUndefined();
+			var svcs = await con.listServices();
+			expect(svcs).toHaveLength(1);
+			expect(Object.getPrototypeOf(svcs[0]).constructor.name).toBe('Service');
+			expect(svcs[0].serviceId).toBe(svc.serviceId);
+		});
+
+		test('Describe service', async () => {
+			var svcdetails = await svc.describeService();
+			expect(svcdetails).not.toBeNull();
+			expect(svcdetails).not.toBeUndefined();
+			expect(svcdetails.serviceId).toBe(svc.serviceId);
+			expect(svcdetails.title).toBeNull();
+			expect(typeof svcdetails.url).toBe('string');
+		})
+
+		test('Update service', async () => {
+			var success = await svc.updateService({title: 'Test service'});
+			expect(success).toBeTruthy();
+			var svcdetails = await svc.describeService();
+			expect(svcdetails).not.toBeNull();
+			expect(svcdetails).not.toBeUndefined();
+			expect(svcdetails.serviceId).toBe(svc.serviceId);
+			expect(svcdetails.title).toBe('Test service');
+			expect(typeof svcdetails.url).toBe('string');
+		});
+
+		test('Delete service', async () => {
+			var success = await svc.deleteService();
+			expect(success).toBeTruthy();
+			var svcs = await con.listServices();
+			expect(svcs).toHaveLength(0);
+		});
+	});
+
+	describe('File management', async () => {
+		var con, f;
+		var fileContent = "Lorem ipsum";
+		var fileName = "lorem.txt";
+		beforeAll(async () => {
+			con = await connectWithBasicAuth();
+			// clean up
+			var list = await con.listFiles();
+			await Promise.all(list.map(f => f.deleteFile()));
+			if (!isBrowserEnv) {
+				const fs = require('fs');
+				fs.writeFileSync(fileName, fileContent);
+			}
+		});
+
+		test('List files in general', async () => {
+			var files = await con.listFiles();
+			expect(files).not.toBeNull();
+			expect(files).toHaveLength(0);
+		});
+
+		var f;
+		test('Upload file', async () => {
+			f = await con.createFile(fileName);
+			expect(Object.getPrototypeOf(f).constructor.name).toBe('File');
+			expect(f.name).toBe(fileName);
+			expect(f.userId).toBe(TESTUSERNAME);
+			var files = await con.listFiles();
+			expect(files).toHaveLength(0); // SIC!!! Zero! createFile only creates it locally
+			await f.uploadFile(isBrowserEnv ? fileContent : fileName);
+			var files = await con.listFiles();
+			expect(files).toHaveLength(1); // now it should be there
+			expect(Object.getPrototypeOf(files[0]).constructor.name).toBe('File');
+			expect(files[0].name).toBe(f.name);
+		});
+
+		test('Get file contents', async (done) => {
+			var resource = await f.downloadFile();
+			expect(resource).not.toBeNull();
+			if (isBrowserEnv) { // Browser environment
+				expect(resource).toBeInstanceOf(Blob);
+				var reader = new FileReader();
+				reader.addEventListener("loadend", () => {
+					// expect(...) can throw itself, so we have to wrap this assertion in try/catch.
+					// Otherwise it could happen that done() is never called!
+					try {
+						expect(reader.result).toBe(fileContent);
+						done();
+					}
+					catch(error) {
+						console.log(error); // it's not being printed by expect itself
+						done.fail();
+					}
+				});
+				reader.readAsText(resource);
+			}
+			else { // Node environment
+				const stream = require('stream');
+				expect(resource).toBeInstanceOf(stream.Readable);
+
+				const chunks = [];
+				resource.on("data", function (chunk) {
+					chunks.push(chunk);
+				});
+				resource.on("end", function () {
+					expect(Buffer.concat(chunks).toString()).toBe(fileContent);
+					done();
+				});
+			}
+		});
+
+		test('Download/Save file', async () => {
+			var target = "downloaded_file.txt";
+			if (isBrowserEnv) { 
+				// Browser environment
+				// Hard to test a browser download, ignore
+				return;
+			}
+			else {
+				// Node environment
+				const fs = require('fs');
+				// Make sure no old file exists
+				if (fs.existsSync(target)) {
+					fs.unlinkSync(target);
+				}
+				expect(fs.existsSync(target)).toBeFalsy();
+				// Download file
+				await f.downloadFile(target);
+				expect(fs.existsSync(target)).toBeTruthy();
+				expect(fs.readFileSync(target).toString()).toBe(fileContent);
+			}
+		})
+
+		test('Update file being not supported', async () => {
+			expect(f.updateFile).toBeUndefined();
+			expect(f.replaceFile).toBeUndefined();
+		});
+
+		test('Delete file', async () => {
+			var success = await f.deleteFile();
+			expect(success).toBeTruthy();
+			var files = await con.listFiles();
+			expect(files).toHaveLength(0);
+		});
+	});
+
+	describe('Subscriptions', async () => {
+		var fileName = 'randomnumber.txt';
+		var prepareFile = async (f) => {
+			var content = Math.random().toString(36);
+			if (!isBrowserEnv) {
+				const fs = require('fs');
+				fs.writeFileSync(fileName, content);
+				await f.uploadFile(fileName);
+			}
+			else {
+				await f.uploadFile(content);
+			}
+			return content;
+		}
+		var con, f, iid;
+
+		beforeAll(async (done) => {
+			con = await connectWithBasicAuth();
+			f = await con.createFile(fileName);
+			await prepareFile(f);
+			done();
+		});
+
+		test('Subscribe to openeo.files', async (done) => {
+			con.subscribe('openeo.files', {}, (payload, message) => {
+				clearInterval(iid); // Stop uploading files
+				con.unsubscribe('openeo.files', {}); // Unsubscribe to avoid receiving the file delete message
+//				expect(message.issued).toBe(... an ISO datetime string);
+				expect(message.topic).toBe('openeo.files');
+				expect(payload.user_id).toBe(TESTUSERNAME);
+				expect(payload.path).toBe(fileName);
+				expect(payload.action).toBe('updated');
+				done();
+			});
+			// Upload files every second to ensure a message is sent by the server during the test.
+			iid = setInterval(async () => {
+				await prepareFile(f);
+			}, 1000);
+		});
+
+		afterAll(async (done) => {
+			await f.deleteFile();
+			done();
+		});
+	});
+	
+	describe('Other tests', () => {
+		test('Base64 encoder', async () => {
+			await connectWithoutAuth().then(con => {
+				expect(con._base64encode(Buffer.from("test"))).toBe("dGVzdA==");
+				expect(con._base64encode("test")).toBe("dGVzdA==");
+			});
+		});
+	});
+
+});