[tilemap/config] Fix url manipulation and promise (#9780)

Backports PR #9754

**Commit 1:**
[ui/vis_maps/tests] use $injector to avoid awkward naming

* Original sha: 52d35fb
* Authored by spalger <spalger@users.noreply.github.com> on 2017-01-04T19:39:37Z

**Commit 2:**
[ui/vis_maps/tests] avoid boolean assertions for better error messages

* Original sha: b118a07
* Authored by spalger <spalger@users.noreply.github.com> on 2017-01-04T20:39:53Z

**Commit 3:**
[ui/vis_maps/tests] verify addQueryParams behavior over time

* Original sha: dff8315
* Authored by spalger <spalger@users.noreply.github.com> on 2017-01-05T19:31:45Z

**Commit 4:**
[ui/vis_maps/tests] stub tilemapsConfig rather than monkey-patching it

* Original sha: 3099bb0
* Authored by spalger <spalger@users.noreply.github.com> on 2017-01-04T20:52:30Z

**Commit 5:**
[ui/vis_maps] remove async/await usage because angular

* Original sha: 084b914
* Authored by spalger <spalger@users.noreply.github.com> on 2017-01-04T21:00:21Z

**Commit 6:**
[ui/vis_maps/tests] add failing test

* Original sha: f38e7dc
* Authored by spalger <spalger@users.noreply.github.com> on 2017-01-05T20:21:20Z

**Commit 7:**
[ui/url] add modifyUrl() helper

* Original sha: d4b9849
* Authored by spalger <spalger@users.noreply.github.com> on 2017-01-03T19:40:20Z

**Commit 8:**
[ui/vis_maps] use modifyUrl() helper to extend query string

* Original sha: bf4083f
* Authored by spalger <spalger@users.noreply.github.com> on 2017-01-03T19:49:56Z

**Commit 9:**
Merge branch 'master' of github.com:elastic/kibana into fix/tilemap-manifest-url-manipulation

* Original sha: 22669aa
* Authored by spalger <spalger@users.noreply.github.com> on 2017-01-06T19:21:41Z

Author: elastic-jasper

src/ui/public/url/__tests__/modify_url.js

@@ -0,0 +1,44 @@
+import { parse as parseUrl } from 'url';
+
+import expect from 'expect.js';
+
+import { modifyUrl } from '../modify_url';
+
+describe('modifyUrl()', () => {
+  it('throws an error with invalid input', () => {
+    expect(() => modifyUrl(1, () => {})).to.throwError();
+    expect(() => modifyUrl(undefined, () => {})).to.throwError();
+    expect(() => modifyUrl('http://localhost')).to.throwError(); // no block
+  });
+
+  it('supports returning a new url spec', () => {
+    expect(modifyUrl('http://localhost', () => ({}))).to.eql('');
+  });
+
+  it('supports modifying the passed object', () => {
+    expect(modifyUrl('http://localhost', parsed => {
+      parsed.port = 9999;
+      parsed.auth = 'foo:bar';
+    })).to.eql('http://foo:bar@localhost:9999/');
+  });
+
+  it('supports changing pathname', () => {
+    expect(modifyUrl('http://localhost/some/path', parsed => {
+      parsed.pathname += '/subpath';
+    })).to.eql('http://localhost/some/path/subpath');
+  });
+
+  it('supports changing port', () => {
+    expect(modifyUrl('http://localhost:5601', parsed => {
+      parsed.port = (parsed.port * 1) + 1;
+    })).to.eql('http://localhost:5602/');
+  });
+
+  it('supports changing protocol', () => {
+    expect(modifyUrl('http://localhost', parsed => {
+      parsed.protocol = 'mail';
+      parsed.slashes = false;
+      parsed.pathname = null;
+    })).to.eql('mail:localhost');
+  });
+});

src/ui/public/url/index.js

@@ -0,0 +1,2 @@
+export { KbnUrlProvider as default } from './url';
+export { modifyUrl } from './modify_url';

src/ui/public/url/modify_url.js

@@ -0,0 +1,61 @@
+import { parse as parseUrl, format as formatUrl } from 'url';
+
+/**
+ *  Takes a URL and a function that takes the meaningful parts
+ *  of the URL as a key-value object, modifies some or all of
+ *  the parts, and returns the modified parts formatted again
+ *  as a url.
+ *
+ *  Url Parts sent:
+ *    - protocol
+ *    - slashes (does the url have the //)
+ *    - auth
+ *    - hostname (just the name of the host, no port or auth information)
+ *    - port
+ *    - pathmame (the path after the hostname, no query or hash, starts
+ *        with a slash if there was a path)
+ *    - query (always an object, even when no query on original url)
+ *    - hash
+ *
+ *  Why?
+ *    - The default url library in node produces several conflicting
+ *      properties on the "parsed" output. Modifying any of these might
+ *      lead to the modifications being ignored (depending on which
+ *      property was modified)
+ *    - It's not always clear wither to use path/pathname, host/hostname,
+ *      so this trys to add helpful constraints
+ *
+ *  @param  {String} url - the url to parse
+ *  @param  {Function<Object|undefined>} block - a function that will modify the parsed url, or return a new one
+ *  @return {String} the modified and reformatted url
+ */
+export function modifyUrl(url, block) {
+  if (typeof block !== 'function') {
+    throw new TypeError('You must pass a block to define the modifications desired');
+  }
+
+  const parsed = parseUrl(url, true);
+
+  // copy over the most specific version of each
+  // property. By default, the parsed url includes
+  // several conflicting properties (like path and
+  // pathname + search, or search and query) and keeping
+  // track of which property is actually used when they
+  // are formatted is harder than necessary
+  const meaningfulParts = {
+    protocol: parsed.protocol,
+    slashes: parsed.slashes,
+    auth: parsed.auth,
+    hostname: parsed.hostname,
+    port: parsed.port,
+    pathname: parsed.pathname,
+    query: parsed.query || {},
+    hash: parsed.hash,
+  };
+
+  // the block modifies the meaningfulParts object, or returns a new one
+  const modifications = block(meaningfulParts) || meaningfulParts;
+
+  // format the modified/replaced meaningfulParts back into a url
+  return formatUrl(modifications);
+}

src/ui/public/url/url.js

@@ -8,8 +8,8 @@ import AppStateProvider from 'ui/state_management/app_state';
 uiModules.get('kibana/url')
 .service('kbnUrl', function (Private) { return Private(KbnUrlProvider); });
 
-function KbnUrlProvider($injector, $location, $rootScope, $parse, Private) {
-  let self = this;
+export function KbnUrlProvider($injector, $location, $rootScope, $parse, Private) {
+  const self = this;
 
   /**
    * Navigate to a url
@@ -198,5 +198,3 @@ function KbnUrlProvider($injector, $location, $rootScope, $parse, Private) {
     return (reloadOnSearch && searchSame) || !reloadOnSearch;
   };
 }
-
-export default KbnUrlProvider;

src/ui/public/vis_maps/__tests__/tile_maps/tilemap_settings.js

@@ -3,40 +3,57 @@ import ngMock from 'ng_mock';
 import url from 'url';
 
 describe('tilemaptest - TileMapSettingsTests-deprecated', function () {
-  let theTileMapSettings;
-  let theTilemapsConfig;
-
-  beforeEach(ngMock.module('kibana'));
-  beforeEach(ngMock.inject(function (Private, tilemapSettings, tilemapsConfig) {
-    theTileMapSettings = tilemapSettings;
-    theTilemapsConfig = tilemapsConfig;
-    theTilemapsConfig.deprecated.isOverridden = true;
+  let tilemapSettings;
+  let tilemapsConfig;
+  let loadSettings;
+
+  beforeEach(ngMock.module('kibana', ($provide) => {
+    $provide.decorator('tilemapsConfig', () => ({
+      manifestServiceUrl: 'https://proxy-tiles.elastic.co/v1/manifest',
+      deprecated: {
+        isOverridden: true,
+        config: {
+          url: 'https://tiles.elastic.co/v1/default/{z}/{x}/{y}.png?my_app_name=kibana_tests',
+          options: {
+            minZoom: 1,
+            maxZoom: 10,
+            attribution: '© [Elastic Tile Service](https://www.elastic.co/elastic_tile_service)'
+          }
+        },
+      }
+    }));
   }));
 
+  beforeEach(ngMock.inject(function ($injector, $rootScope) {
+    tilemapSettings = $injector.get('tilemapSettings');
+    tilemapsConfig = $injector.get('tilemapsConfig');
 
-  describe('getting settings', function () {
+    loadSettings = () => {
+      tilemapSettings.loadSettings();
+      $rootScope.$digest();
+    };
+  }));
 
-    beforeEach(async function () {
-      await theTileMapSettings.loadSettings();
+  describe('getting settings', function () {
+    beforeEach(function () {
+      loadSettings();
     });
 
-    it('should get url', async function () {
+    it('should get url', function () {
 
-      const mapUrl = theTileMapSettings.getUrl();
-      expect(mapUrl.indexOf('{x}') > -1).to.be.ok();
-      expect(mapUrl.indexOf('{y}') > -1).to.be.ok();
-      expect(mapUrl.indexOf('{z}') > -1).to.be.ok();
+      const mapUrl = tilemapSettings.getUrl();
+      expect(mapUrl).to.contain('{x}');
+      expect(mapUrl).to.contain('{y}');
+      expect(mapUrl).to.contain('{z}');
 
       const urlObject = url.parse(mapUrl, true);
-      expect(urlObject.host.endsWith('elastic.co')).to.be.ok();
-      expect(urlObject.query).to.have.property('my_app_name');
-      expect(urlObject.query).to.have.property('my_app_version');
-      expect(urlObject.query).to.have.property('elastic_tile_service_tos');
+      expect(urlObject.hostname).to.be('tiles.elastic.co');
+      expect(urlObject.query).to.have.property('my_app_name', 'kibana_tests');
 
     });
 
-    it('should get options', async function () {
-      const options = theTileMapSettings.getOptions();
+    it('should get options', function () {
+      const options = tilemapSettings.getOptions();
       expect(options).to.have.property('minZoom');
       expect(options).to.have.property('maxZoom');
       expect(options).to.have.property('attribution');