TestCode.java | searchcode

/core/infinit.e.data_model/src/com/ikanow/infinit/e/data_model/test/TestCode.java

https://github.com/IKANOW/Infinit.e
Java | 508 lines | 320 code | 59 blank | 129 comment | 40 complexity | cfe6a2a3247b63c983007ad4c38a88c8 MD5 | raw file
Possible License(s): BSD-3-Clause

/*******************************************************************************
 * Copyright 2012 The Infinit.e Open Source Project
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/
package com.ikanow.infinit.e.data_model.test;

import java.io.IOException;
import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.bson.types.ObjectId;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.common.settings.ImmutableSettings;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.reflect.TypeToken;
import com.ikanow.infinit.e.data_model.Globals;
import com.ikanow.infinit.e.data_model.Globals.Identity;
import com.ikanow.infinit.e.data_model.store.BaseDbPojo;
import com.ikanow.infinit.e.data_model.store.DbManager;
import com.ikanow.infinit.e.data_model.store.social.community.CommunityPojo;
import com.ikanow.infinit.e.data_model.store.social.sharing.SharePojo;
import com.ikanow.infinit.e.data_model.api.ApiManager;
import com.ikanow.infinit.e.data_model.api.BaseApiPojo;
import com.ikanow.infinit.e.data_model.api.BasePojoApiMap;
import com.ikanow.infinit.e.data_model.api.ResponsePojo;
import com.ikanow.infinit.e.data_model.api.ResponsePojo.ResponseObject;
import com.ikanow.infinit.e.data_model.api.config.SourcePojoApiMap;
import com.ikanow.infinit.e.data_model.api.knowledge.AdvancedQueryPojo;
import com.ikanow.infinit.e.data_model.api.knowledge.AdvancedQueryPojo.QueryTermPojo;
import com.ikanow.infinit.e.data_model.api.knowledge.DocumentPojoApiMap;
import com.ikanow.infinit.e.data_model.api.social.sharing.SharePojoApiMap;
import com.ikanow.infinit.e.data_model.driver.InfiniteDriver;
import com.ikanow.infinit.e.data_model.index.ElasticSearchManager;
import com.ikanow.infinit.e.data_model.index.IndexManager;
import com.ikanow.infinit.e.data_model.index.document.DocumentPojoIndexMap;
import com.ikanow.infinit.e.data_model.store.config.source.SourcePojo;
import com.ikanow.infinit.e.data_model.store.document.DocumentPojo;
import com.ikanow.infinit.e.data_model.store.document.EntityPojo;
import com.ikanow.infinit.e.data_model.store.feature.entity.EntityFeaturePojo;
import com.mongodb.BasicDBList;
import com.mongodb.BasicDBObject;
import com.mongodb.DBCollection;
import com.mongodb.MongoException;

public class TestCode {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws MongoException 
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException, MongoException, IOException {

		System.out.println(Arrays.toString(args));
		Globals.setIdentity(Identity.IDENTITY_SERVICE);
		Globals.overrideConfigLocation(args[0]);
		
/////////////////////////////////////////////////////////////////////////////
		
// SOME DRIVER TESTING
		
		// Redirects
		
		boolean testRedirects = false;
		if (testRedirects) {
			// GET
			String rootUrl = args[1];
			String username = args[2];
			String password = args[3];
			InfiniteDriver infDriver = new InfiniteDriver(rootUrl);
			System.out.println("LOGIN=" + infDriver.login(username, password, new ResponseObject()));
			
			//POST
			AdvancedQueryPojo query = new AdvancedQueryPojo();
			QueryTermPojo qt = new QueryTermPojo();
			qt.etext = "*";
			query.qt = Arrays.asList(qt);
			ResponseObject response = new ResponseObject();
			ObjectId communityId = new ObjectId("4c927585d591d31d7b37097a");
			ResponsePojo retVal = infDriver.sendQuery(query, communityId, response);
			
			System.out.println("RETURNED " + retVal.getStats().found  + " docs");
			
			return;
		}		
		
		// Aliases:		
		
		boolean bTestAliases = false;
		if (bTestAliases) { // will need to set some variables...
		
			String rootUrl = "http://infinite.ROOT.com/api/";
			String apiKey = "API_KEY";
			
			InfiniteDriver infDriver = new InfiniteDriver(rootUrl, apiKey);
			
			String aliasCommIdStr = "4d38b72c054548f038a0414a";
			String emptyAliasCommIdStr = "506afc85e4b01d98fcf9bf5f";
			ResponseObject response = new ResponseObject(); 
			Map<String, List<SharePojo>> aliasMapping = new HashMap<String, List<SharePojo>>();
			Map<String, EntityFeaturePojo> aliases = infDriver.getAliases(aliasCommIdStr, aliasMapping, response);
			
			if (response.isSuccess()) {
				System.out.println("ALIASES: " + new com.google.gson.Gson().toJson(aliases));
				System.out.println("ALIAS MAPPINGS: " + new com.google.gson.Gson().toJson(aliasMapping));
			}
			else {
				System.out.println("FAIL: " + response.getMessage());
			}
			// Change 1 of the aliases
			Iterator<EntityFeaturePojo> it = aliases.values().iterator();
			EntityFeaturePojo alias = it.next();
			alias.addToSemanticLinks(Arrays.asList("AlexTest"));
			EntityFeaturePojo alias2 = it.next();
			alias2.addAlias("XXXXX/person");
			Set<String> failures = infDriver.updateAliases(Arrays.asList(alias, alias2), aliasCommIdStr, false, response);
			if (!response.isSuccess()) {
				System.out.println("UPDATE TOTAL FAILURE: " + response.getMessage());
			}
			else if (!failures.isEmpty()) {
				System.out.println("UPDATE FAILURES: " + Arrays.toString(failures.toArray()));
			}
			else {
				System.out.println("UPDATED " + alias.getIndex() + " AND " + alias2.getIndex());
			}
			// Check upserting (failure and success) into an existing share
			// upsert fail:
			String savedAlias = alias.getIndex();
			alias.setIndex("testXXX/person");
			if (aliases.containsKey("testXXX/person")) {
				System.out.println("(skipping upsert fail, target index exists)");
			}
			else {
				failures = infDriver.updateAliases(Arrays.asList(alias, alias2), aliasCommIdStr, false, response);
				if (!response.isSuccess()) {
					System.out.println("UPDATE TOTAL FAILURE (CORRECT IF ONLY 1 ALIAS SPECIFIED): " + response.getMessage() + " " + Arrays.toString(failures.toArray()));
				}
				else if (!failures.isEmpty()) {
					System.out.println("UPSERT CORRECTLY FAILS: " + Arrays.toString(failures.toArray()));
				}
				else {
					System.out.println("INCORRECTLY UPDATED " + alias.getIndex());
				}
			}
			// upsert success:
			failures = infDriver.updateAliases(Arrays.asList(alias), aliasCommIdStr, true, response);
			if (!response.isSuccess()) {
				System.out.println("UPDATE TOTAL FAILURE: " + response.getMessage());
			}
			else if (!failures.isEmpty()) {
				System.out.println("UPDATE FAILURES: " + Arrays.toString(failures.toArray()));
			}
			else {
				System.out.println("UPDATED " + alias.getIndex());
			}
			// Check upserting into a new community			
			failures = infDriver.updateAliases(Arrays.asList(alias), emptyAliasCommIdStr, true, response);
			if (!response.isSuccess()) {
				System.out.println("UPDATE TOTAL FAILURE: " + response.getMessage());
			}
			else if (!failures.isEmpty()) {
				System.out.println("UPDATE FAILURES: " + Arrays.toString(failures.toArray()));
			}
			else {
				System.out.println("UPDATED " + alias.getIndex());
			}
			// Check removal
			boolean bRemoval = true;
			if (bRemoval) {
				failures = infDriver.removeAliases(Arrays.asList(alias.getIndex()), emptyAliasCommIdStr, response);
				if (!response.isSuccess()) {
					System.out.println("REMOVE TOTAL FAILURE: " + response.getMessage());
				}
				else if (!failures.isEmpty()) {
					System.out.println("REMOVE FAILURES: " + Arrays.toString(failures.toArray()));
				}
				else {
					System.out.println("REMOVE " + alias.getIndex());
				}
				failures = infDriver.removeAliases(Arrays.asList(alias.getIndex()), aliasCommIdStr, response);
				if (!response.isSuccess()) {
					System.out.println("REMOVE TOTAL FAILURE: " + response.getMessage());
				}
				else if (!failures.isEmpty()) {
					System.out.println("REMOVE FAILURES: " + Arrays.toString(failures.toArray()));
				}
				else {
					System.out.println("REMOVE " + alias.getIndex());
				}
				// Reset old shares back again
				alias.setIndex(savedAlias);
				if (null != alias.getSemanticLinks()) {
					alias.getSemanticLinks().remove("AlexTest");
				}
				alias.getAlias().remove("XXXXX/person");
				if (null != alias2.getSemanticLinks()) {
					alias2.getSemanticLinks().remove("AlexTest");
				}
				alias2.getAlias().remove("XXXXX/person");
				failures = infDriver.updateAliases(Arrays.asList(alias, alias2), aliasCommIdStr, false, response);
				System.out.println("RESET: " + response.isSuccess() + " " + (2 - failures.size()));
			}
		}//(end alias testing)
		
/////////////////////////////////////////////////////////////////////////////
		
// API testing:
		
		// API: Variable community source pojo...
		ResponsePojo rp1 = new ResponsePojo();
		SourcePojo sp = new SourcePojo();
		sp.setUrl("http://test");
		sp.setKey(sp.generateSourceKey());
		sp.addToCommunityIds(new ObjectId("a0000000000000000000000a"));
		sp.addToCommunityIds(new ObjectId("c0000000000000000000000c"));
		//CHECK THIS DOESN'T COMPILE
		//rp1.setData(sp); // (Not allowed SourcePojo isn't a BaseApiPojo)

		////////////////////////////////////////////////
		//CANONICAL EXAMPLE:
		Set<ObjectId> communities = new HashSet<ObjectId>();
		communities.add(new ObjectId("a0000000000000000000000a"));
		rp1.setData(sp, new SourcePojoApiMap(null, communities, communities));
		String sRPSingleObject = rp1.toApi();
		System.out.println("RPa=" + sRPSingleObject); // ("chris" removed, toApi handles RepsonsePojo specially)
		////////////////////////////////////////////////
		System.out.println("RPb=" + ResponsePojo.toApi(rp1, rp1.getMapper())); // ("chris" removed because of mapper)
		System.out.println("RPc=" + ResponsePojo.toApi(rp1)); // ("chris" removed, toApi handles RepsonsePojo specially)
		
		//API: Get an non-API object
		String sJson = "{ 'url':'http://test2', 'isApproved': false, 'harvestBadSource': true, 'created': 'Feb 14, 2013 9:24:34 PM' } ";
		//sp = BaseApiPojo.mapFromApi(sJson, SourcePojo.class, null);
		// Equivalent to:
		SourcePojo sp2 = ApiManager.mapFromApi(sJson, SourcePojo.class, new SourcePojoApiMap(null, new HashSet<ObjectId>(), new HashSet<ObjectId>()));
		System.out.println("RPd="+new Gson().toJson(sp2)); // "alex" and "chris" both removed
		
		//API: add a list to the response Pojo
		List<SourcePojo> list = Arrays.asList(sp, sp2);
		//CHECK THIS DOESN'T COMPILE
		//rp1.setData(list); // (Not allowed SourcePojo isn't a BaseApiPojo)

		sp2.addToCommunityIds(new ObjectId("a0000000000000000000000a")); // (alex will be allowed again)
		rp1.setData(list, new SourcePojoApiMap(null, communities, communities));
		String sRPList = rp1.toApi(); 
		sp2.setCommunityIds(null);
		
		//API:  And get as a list
		String listJson =  BaseApiPojo.getDefaultBuilder().create().toJson(rp1.getData());
		System.out.println("RP=" + listJson); // include "alex" and "chris" - no mapping applied
		
		////////////////////////////////////////////////
		//CANONICAL EXAMPLE:
		list = ApiManager.mapListFromApi(listJson, SourcePojo.listType(), null);
		////////////////////////////////////////////////
		System.out.println("SPL=" + BaseApiPojo.getDefaultBuilder().create().toJson(list)); // both "alex" and "chris", no mapping "from API"
		Set<SourcePojo> set = ApiManager.mapListFromApi(BaseApiPojo.getDefaultBuilder().create().toJson(rp1.getData()), new TypeToken<Set<SourcePojo>>(){}, null);
		System.out.println("SPS=" + BaseApiPojo.getDefaultBuilder().create().toJson(set)); // both "alex" and "chris", no mapping "from API"
		
		// API: finally transform to a JSON list (applies mapping)	
		try {
			System.out.println("SPJ=" + ApiManager.mapListToApi(set, new TypeToken<Set<SourcePojo>>(){}, new SourcePojoApiMap(null, null, communities)));
				// should fail because one of the communities does not have
			System.out.println("**********FAILED SHOULD HAVE THROWN SECURITY EXCEPTION");
		}
		catch (RuntimeException e) {
			// Add "communities" to object with missing val
			for (SourcePojo spSet: set) {
				if (null == spSet.getCommunityIds()) {
					spSet.setCommunityIds(communities);
				}
			}			
			// Try again:
			System.out.println("SPJ=" + ApiManager.mapListToApi(set, new TypeToken<Set<SourcePojo>>(){}, new SourcePojoApiMap(null, communities, communities)));
				// (just has "alex")			
		}
		
		// And now in the other direction, ie deserializing....
		ResponsePojo rpRecreated = ResponsePojo.fromApi(sRPSingleObject, ResponsePojo.class, SourcePojo.class, new SourcePojoApiMap(null, communities, communities));
		System.out.println("RECREATED RP_SRC=" + rpRecreated.toApi());
		System.out.println("RECREATED SRC(RP_SRC)=" + ((BasicDBObject)((SourcePojo)rpRecreated.getData()).toDb()).toString());
		rpRecreated = ResponsePojo.listFromApi(sRPList, ResponsePojo.class, SourcePojo.listType(), new SourcePojoApiMap(null, communities, communities));
		System.out.println("RECREATED RP_LSRC=" + rpRecreated.toApi());
		
		rpRecreated = ResponsePojo.fromApi(sRPSingleObject, ResponsePojo.class);
		System.out.println("RECREATED RAW(RP_SRC)=" + ((JsonElement)rpRecreated.getData()));
		sp = ApiManager.mapFromApi((JsonElement)rpRecreated.getData(), SourcePojo.class, new SourcePojoApiMap(null, communities, communities));
		System.out.println("RECREATED SRC(RAW(RP_SRC))=" + ((JsonElement)rpRecreated.getData()));
		
		// Real-life source pojo testing:
		// No longer needed - if commented in will fail because communities not assigned in mapTo/FromApi
//		BasicDBObject srcQuery = new BasicDBObject("useExtractor", "ModusOperandi");
//		SourcePojo fileSource = SourcePojo.fromDb(DbManager.getConfig().getSource().findOne(srcQuery), SourcePojo.class);
//		System.out.println("MODUS=" + ApiManager.mapToApi(fileSource, new SourcePojoApiMap(new HashSet<ObjectId>())));
//		ResponsePojo testRP = new ResponsePojo();
//		testRP.setData(fileSource, new SourcePojoApiMap(new HashSet<ObjectId>()));
//		System.out.println("MODUS2=" + testRP.toApi());		
//		srcQuery = new BasicDBObject("useExtractor", "none");
//		fileSource = SourcePojo.fromDb(DbManager.getConfig().getSource().findOne(srcQuery), SourcePojo.class);
//		System.out.println("SAH=" + ApiManager.mapToApi(fileSource, new SourcePojoApiMap(new HashSet<ObjectId>())));
//		testRP.setData(fileSource, new SourcePojoApiMap(new HashSet<ObjectId>()));
//		System.out.println("SAH2=" + testRP.toApi());
		
		//API: Get an API object
		////////////////////////////////////////////////
		//CANONICAL EXAMPLE:
		String sQueryJson = "{ 'logic': 'alex' }";
		AdvancedQueryPojo aqp = AdvancedQueryPojo.fromApi(sQueryJson, AdvancedQueryPojo.class);
		//AdvancedQueryPojo aqp = AdvancedQueryPojo.fromApi(sQueryJson, new TypeToken<AdvancedQueryPojo>(){});
			//^^^ (equivalent, needed for types that are generics) 
		////////////////////////////////////////////////
		System.out.println("AQP="+new Gson().toJson(aqp));
		
		// Testing ResponsePojo code on serialization
		rp1.setData(aqp);
		sRPSingleObject = rp1.toApi();
		rpRecreated = ResponsePojo.fromApi(sRPSingleObject, ResponsePojo.class, AdvancedQueryPojo.class);
		System.out.println("RECREATED RP_AQP=" + rpRecreated.toApi());
		System.out.println("RECREATED AQP(RP_AQP)=" + ((AdvancedQueryPojo)(rpRecreated.getData())).toApi());
		
		//API: Get a list of objects		
		sQueryJson = "{ 'logic': 'chris' }";
		AdvancedQueryPojo aqp2 = AdvancedQueryPojo.fromApi(sQueryJson, AdvancedQueryPojo.class);
		List<AdvancedQueryPojo> list2 = Arrays.asList(aqp, aqp2);
		rp1.setData(list2);
		sRPList = rp1.toApi();
		System.out.println("RP=" + sRPList);
		// This won't compile because didn't write a listType() for AQP (since it's never actually used in this way)
		//rpRecreated = ResponsePojo.listFromApi(sRPList, ResponsePojo.class, AdvancedQueryPojo.listType());
		rpRecreated = ResponsePojo.listFromApi(sRPList, ResponsePojo.class, new TypeToken<List<AdvancedQueryPojo>>(){});
		System.out.println("RECREATED RP_AQP=" + rpRecreated.toApi());
		
		////////////////////////////////////////////////
		//CANONICAL EXAMPLE:
		sQueryJson = " [ { 'logic': 'alex' } , { 'logic': 'chris' } ] ";
		list2 = AdvancedQueryPojo.listFromApi(sQueryJson, new TypeToken<List<AdvancedQueryPojo>>(){});
		////////////////////////////////////////////////
		System.out.println("APL=" + new Gson().toJson(list2));
		
		//API: BasicDBList (like feeds in the full system)
		BasicDBList dbl = new BasicDBList();
		BasicDBObject db01 = new BasicDBObject("index", 1);
		BasicDBObject db02 = new BasicDBObject("index", 2);
		BasicDBObject db03 = new BasicDBObject("index", 3);
		dbl.addAll(Arrays.asList(db01, db02, db03));
		ResponsePojo rp2 = new ResponsePojo(null, dbl, (BasePojoApiMap<BasicDBList>)null);
		System.out.println("DBO=" + rp2.toApi());
		
		//API: test the V0 DocumentPojo, which has a few differences (including a static version for raw modification)
		BasicDBObject docApiDbo = (BasicDBObject) DbManager.getDocument().getMetadata().findOne();
		// (remove a few things to tidy up display)
		docApiDbo.remove("entities");
		docApiDbo.remove("associations");
		docApiDbo.remove("metadata");
		// (remove things as a test)
//		docApiDbo.remove("sourceKey");
//		docApiDbo.remove("source");
//		docApiDbo.remove("mediaType");
		// (sourceKey in <key>#<community> format)
//		docApiDbo.put("sourceKey", docApiDbo.getString("sourceKey")+"#doc_api_test");
		// (display results of API mappings)
		DocumentPojo docApi = DocumentPojo.fromDb(docApiDbo, DocumentPojo.class);
		ResponsePojo rp3 = new ResponsePojo(null, docApi, new DocumentPojoApiMap());

		System.out.println("TIME_DOC_API1_CREATED="+docApi.getCreated());
		System.out.println("DOC_API1=" + rp3.toApi());
		DocumentPojoApiMap.mapToApi(docApiDbo);
		System.out.println("DOC_API2=" + BaseApiPojo.getDefaultBuilder().setPrettyPrinting().create().toJson(docApiDbo));
		DocumentPojo docFromApi = ApiManager.mapFromApi(ApiManager.mapToApi(docApi, null), DocumentPojo.class, null);
		System.out.println("TIME_DOC_API1_CREATED_INV="+docFromApi.getCreated());
		
/////////////////////////////////////////////////////////////////////////////
		
// DB testing:
		System.out.println("Open Community DB collection");
		//OLD:
		//CollectionManager cm = new CollectionManager();
		//DBCollection communityDb = cm.getCommunities();
		//NEW:
		DBCollection communityDb = DbManager.getSocial().getCommunity();
		
		//DB: read/write community object
		////////////////////////////////////////////////
		//CANONICAL EXAMPLE:
		CommunityPojo cp = CommunityPojo.fromDb(communityDb.findOne(), CommunityPojo.class);
		System.out.println("CP1=" + cp.toDb()); // (converts DBObject to string ie BSON->JSON - should have { $oid } and { $date } objectid/date formats)
		////////////////////////////////////////////////
		System.out.println("CP2=" + new Gson().toJson(cp)); // (will have complex object id format and string dates)
		//DB: read/write list of community objects
		////////////////////////////////////////////////
		//CANONICAL EXAMPLE:
		List<CommunityPojo> cpl = CommunityPojo.listFromDb(communityDb.find().limit(3), CommunityPojo.listType());
		System.out.println("CPL1=" + CommunityPojo.listToDb(cpl, CommunityPojo.listType()));
		////////////////////////////////////////////////
		System.out.println("CPL2=" + BaseDbPojo.getDefaultBuilder().create().toJson(cpl)); // (will have complex object id format and string dates)

		//Expect to see another delay here with the old method, new method should roll on...
		System.out.println("Open Document DB collection");
		//OLD:
		//CollectionManager cm2 = new CollectionManager();
		//DBCollection documentDb = cm2.getFeeds();
		//NEW:
		DBCollection documentDb = DbManager.getDocument().getMetadata();
		
		//DB: Read/write feed with metadata
		BasicDBObject query = new BasicDBObject("metadata", new BasicDBObject("$exists", true)); // (complex query so can't represent using pojos)
		query.put("entities", new BasicDBObject("$size", 3));
		////////////////////////////////////////////////
		//CANONICAL EXAMPLE:
		DocumentPojo doc = DocumentPojo.fromDb(documentDb.findOne(query), DocumentPojo.class);
		System.out.println("DOC1="+doc.toDb());
		BasicDBList dblTest = (BasicDBList) doc.toDb().get("entities");
		BasicDBObject dboTest = (BasicDBObject) dblTest.get(0);
		if (!dboTest.get("doccount").getClass().toString().equals("class java.lang.Long")) {
			throw new RuntimeException(dboTest.get("doccount").getClass().toString() + " SHOULD BE LONG");
		}
		////////////////////////////////////////////////
		System.out.println("DOC2="+new Gson().toJson(doc));
		doc = DocumentPojo.fromDb(documentDb.findOne(query), new TypeToken<DocumentPojo>(){}); // (alternative to the prettier DocumentPojo.class, needed for container classes)
		System.out.println("DOC3="+doc.toDb());
		//DB: list example for doc
		Set<DocumentPojo> docset = DocumentPojo.listFromDb(documentDb.find(query).limit(3), new TypeToken<Set<DocumentPojo>>(){});
		System.out.println("DOCSET="+DocumentPojo.listToDb(docset, new TypeToken<Set<DocumentPojo>>(){}));
		
		// Shares - demonstrate mapping of _ids across to the API (and that binary data is discarded):
		List<SharePojo> shares = SharePojo.listFromDb(DbManager.getSocial().getShare().find().limit(10), SharePojo.listType()); 
		System.out.println("SHARE="+ApiManager.mapListToApi(shares, SharePojo.listType(), new SharePojoApiMap(null)));
		
// Index testing:
		
		////////////////////////////////////////////////
		//CANONICAL EXAMPLE:
		DocumentPojoIndexMap docMap = new DocumentPojoIndexMap();
		System.out.println("DOC_INDEX=" + IndexManager.mapToIndex(doc, docMap));
		
		////////////////////////////////////////////////
		// Check use of enums in Entity pojo works
		EntityPojo testEnt = new EntityPojo(); 
		testEnt.setDimension(EntityPojo.Dimension.Where);
		System.out.println("ENT1=" + new GsonBuilder().setPrettyPrinting().create().toJson(testEnt));		
		System.out.println("DIM=" + testEnt.getDimension());
		BasicDBObject testEntDb = new BasicDBObject("dimension", "Who");
		testEnt = new Gson().fromJson(testEntDb.toString(), EntityPojo.class);
		System.out.println("ENT2=" + new GsonBuilder().setPrettyPrinting().create().toJson(testEnt));
		try {
			testEntDb = new BasicDBObject("dimension", "what");
			testEnt = BaseDbPojo.getDefaultBuilder().create().fromJson(testEntDb.toString(), EntityPojo.class);
			System.out.println("***FAIL=" + BaseDbPojo.getDefaultBuilder().setPrettyPrinting().create().toJson(testEnt));
		}
		catch (Exception e) {
			System.out.println("ENT3: Correctly failed with illegal dimension type");
		}
		
		////////////////////////////////////////////////
		// Metadata transformations based on type:
		
		String metadataObjStr = "{ 'test__long': 3, 'test_long': '3', 'error__long': { 'field1': 'no'}, "+
			"'test_arrayObj': [ { 'field1': 'test' } ], 'test_nestedArrayObj': [ [ { 'field1': 'test' } ]  ], "+
			"'test_array': [ 'val' ], 'test_nestedArray': [ [ 'val' ] ], "+
			"'test_obj': { 'field1': 'string' }, 'test_nestedObj': { 'field1': 'string', 'field2': { 'field3': 'string' }},"+
			"'test_null1': {}, test_null2: null"+
			"}";
		
		BasicDBObject metadataObj = (BasicDBObject) com.mongodb.util.JSON.parse(metadataObjStr);
		
		doc.addToMetadata("TestMeta", metadataObj);
		System.out.println("DOC_META=" + docMap.extendBuilder(BaseApiPojo.getDefaultBuilder()).setPrettyPrinting().create().toJson(doc));
		
// Changes to new ElasticSearch construct (particularly for bulk add)
		
		ElasticSearchManager indexManager = IndexManager.createIndex("test", null, false, null, null, ImmutableSettings.settingsBuilder());
		
		BulkResponse result = null;
		// All docs
		result = indexManager.bulkAddDocuments(IndexManager.mapListToIndex(docset, new TypeToken<Set<DocumentPojo>>(){}, 
																	new DocumentPojoIndexMap()), "_id", null, true);
		if (result.hasFailures()) {
			System.out.print("****** FAILED: ");
			System.out.println(result.buildFailureMessage());
		}
		
		//Delete index (once testing complete)
		indexManager.deleteMe();
		
		
				
	}
}