import * as service from '../src/service';

import * as embed from '../src/embed';

import * as report from '../src/report';

import * as dashboard from '../src/dashboard';

import * as page from '../src/page';

import * as Wpmp from 'window-post-message-proxy';

import * as Hpm from 'http-post-message';

import * as Router from 'powerbi-router';

import * as models from 'powerbi-models';

import { spyApp, setupEmbedMockApp } from './utility/mockEmbed';

import * as factories from '../src/factories';

import { spyWpmp } from './utility/mockWpmp';

import { spyHpm } from './utility/mockHpm';

import { spyRouter } from './utility/mockRouter';

import * as util from '../src/util';

declare global {

interface Window {

__karma__: any;

}

}

function ValidateDashboardConfigurationWorksAsExpected(pageView: string, exceptionExpected: boolean, powerbi: service.Service) {

const embedUrl = `https://app.powerbi.com/dashboardEmbed`;

const component = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report"></div>`)

.appendTo('#powerbi-fixture');

const dashboardEmbedConfig = {

type: "dashboard",

id: "fakeReportId",

accessToken: "fakeAccessToken",

embedUrl: "fakeEmbedUrl",

pageView: pageView

};

powerbi.embed(component[0], <any>dashboardEmbedConfig);

var exceptionThrown = false;

// Act

try {

powerbi.embed(component[0], <any>dashboardEmbedConfig);

}

catch(e) {

exceptionThrown = true;

}

// Assert

expect(exceptionThrown).toBe(exceptionExpected);

}

let logMessages = (window.__karma__.config.args[0] === 'logMessages');

describe('service', function () {

let powerbi: service.Service;

let $element: JQuery;

beforeAll(function () {

powerbi = new service.Service(factories.hpmFactory, factories.wpmpFactory, factories.routerFactory);

powerbi.accessToken = 'ABC123';

$element = $('<div id="powerbi-fixture"></div>').appendTo(document.body);

});

afterAll(function () {

$element.remove();

powerbi.wpmp.stop();

});

afterEach(function () {

$element.empty();

});

it('is defined', function () {

expect(powerbi).toBeDefined();

});

describe('init', function () {

it('embeds all components found in the DOM', function () {

// Arrange

const elements = [

'<div powerbi-embed-url="https://embedded.powerbi.com/appTokenReportEmbed?reportId=ABC123" powerbi-type="report"></div>',

'<div powerbi-embed-url="https://embedded.powerbi.com/appTokenReportEmbed?reportId=XYZ456" powerbi-type="report"></div>',

];

elements.forEach(element => {

$(element).appendTo('#powerbi-fixture');

});

// Act

powerbi.init();

// Assert

// If embed element has iframe inside it, assume embed action occurred

const iframes = document.querySelectorAll('[powerbi-embed-url] iframe');

expect(iframes.length).toEqual(2);

});

});

describe('get', function () {

it('if attempting to get a powerbi component on an element which was not embedded, throw an error', function () {

// Arrange

const $component = $('<div></div>');

// Act

const attemptGet = () => {

powerbi.get($component[0]);

};

// Assert

expect(attemptGet).toThrowError(Error);

});

it('calling get on element with embeded report component returns the instance', function () {

// Arrange

const $element = $('<div powerbi-type="report" powerbi-embed-url="https://app.powerbi.com/reportEmbed?reportId=ABC123"></div>')

.appendTo('#powerbi-fixture');

const componentInstance = powerbi.embed($element[0]);

// Act

const componentInstance2 = powerbi.get($element[0]);

// Assert

expect(componentInstance).toEqual(componentInstance2);

})

it('calling get on element with embeded dashboard component returns the instance', function () {

// Arrange

const $element = $('<div powerbi-type="dashboard" powerbi-embed-url="https://app.powerbi.com/dashboardEmbed?dashboardId=ABC123"></div>')

.appendTo('#powerbi-fixture');

const componentInstance = powerbi.embed($element[0]);

// Act

const componentInstance2 = powerbi.get($element[0]);

// Assert

expect(componentInstance).toEqual(componentInstance2);

})

});

describe('embed', function () {

it('if attempting to embed without specifying a type, throw error', function () {

// Arrange

const component = $('<div></div>')

.appendTo('#powerbi-fixture');

// Act

const attemptEmbed = () => {

powerbi.embed(component[0]);

};

// Assert

expect(attemptEmbed).toThrowError(Error);

});

it('if attempting to embed with an unknown type, throw error', function () {

// Arrange

const component = $('<div powerbi-type="unknownType"></div>')

.appendTo('#powerbi-fixture');

// Act

const attemptEmbed = () => {

powerbi.embed(component[0]);

};

// Assert

expect(attemptEmbed).toThrowError(Error);

});

it('if attempting to embed on existing element with different type than previous embed, throw error', function () {

// Arrange

const component = $('<div></div>')

.appendTo('#powerbi-fixture');

const reportEmbedConfig: embed.IEmbedConfiguration = {

type: "report",

id: "fakeReportId",

accessToken: "fakeAccessToken",

embedUrl: "fakeEmbedUrl"

};

const dashboardEmbedConfig: embed.IEmbedConfiguration = {

type: "dashboard",

id: "fakeDashboardId",

accessToken: "fakeAccessToken",

embedUrl: "fakeEmbedUrl"

};

powerbi.embed(component[0], reportEmbedConfig);

// Act

const attemptEmbed = () => {

powerbi.embed(component[0], dashboardEmbedConfig);

};

// Assert

expect(attemptEmbed).toThrowError(Error);

});

it('if attempting to embed without specifying an embed url, throw error', function () {

// Arrange

const component = $('<div></div>')

.appendTo('#powerbi-fixture');

// Act

const attemptEmbed = () => {

powerbi.embed(component[0], { type: "report", embedUrl: null, accessToken: null, id: null });

};

// Assert

expect(attemptEmbed).toThrowError(Error);

});

it('if attempting to embed without specifying an access token, throw error', function () {

// Arrange

const component = $('<div></div>')

.appendTo('#powerbi-fixture');

const originalToken = powerbi.accessToken;

powerbi.accessToken = undefined;

// Act

const attemptEmbed = () => {

powerbi.embed(component[0], { type: "report", embedUrl: null, accessToken: null, id: null });

};

// Assert

expect(attemptEmbed).toThrowError(Error);

// Cleanup

powerbi.accessToken = originalToken;

});

it('if attempting to embed without specifying an id, throw error', function () {

// Arrange

const embedUrl = `https://embedded.powerbi.com/appTokenReportEmbed`;

const $reportContainer = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report"></div>`)

.appendTo('#powerbi-fixture');

// Act

const attemptToEmbed = () => {

powerbi.embed($reportContainer[0]);

};

// Assert

expect(attemptToEmbed).toThrowError();

});

it('if attempting to embed a dashboard with an invalid pageView, throw error', function () {

ValidateDashboardConfigurationWorksAsExpected("notValid", true, powerbi);

});

it('if attempting to embed a dashboard with a pageView equals fitToWidth, don\'t throw error', function () {

ValidateDashboardConfigurationWorksAsExpected("fitToWidth", false, powerbi);

});

it('if attempting to embed a dashboard with a pageView equals oneColumn, don\'t throw error', function () {

ValidateDashboardConfigurationWorksAsExpected("oneColumn", false, powerbi);

});

it('if attempting to embed a dashboard with a pageView equals actualSize, don\'t throw error', function () {

ValidateDashboardConfigurationWorksAsExpected("actualSize", false, powerbi);

});

it('if attempting to embed a dashboard with an undefined pageView, don\'t throw error', function () {

ValidateDashboardConfigurationWorksAsExpected(undefined, false, powerbi);

});

it('should get uqiqueId from config first', function () {

// Arrange

const testUniqueId = 'fakeUniqueId';

const embedUrl = `https://embedded.powerbi.com/appTokenReportEmbed`;

const $reportContainer = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report" powerbi-report-id="abc123" powerbi-name="differentUniqueId"></div>`)

.appendTo('#powerbi-fixture');

// Act

const report = powerbi.embed($reportContainer[0], { uniqueId: testUniqueId });

// Assert

expect(report.config.uniqueId).toEqual(testUniqueId);

});

it('should get uqiqueId from name attribute if uniqueId is not specified in config', function () {

// Arrange

const testUniqueId = 'fakeUniqueId';

const embedUrl = `https://embedded.powerbi.com/appTokenReportEmbed`;

const $reportContainer = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report" powerbi-report-id="abc123" powerbi-name="${testUniqueId}"></div>`)

.appendTo('#powerbi-fixture');

// Act

const report = powerbi.embed($reportContainer[0]);

// Assert

expect(report.config.uniqueId).toEqual(testUniqueId);

});

it('should generate uqiqueId if uniqueId is not specified in config or attribute', function () {

// Arrange

const testUniqueId = 'fakeUniqueId';

const embedUrl = `https://embedded.powerbi.com/appTokenReportEmbed`;

const $reportContainer = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report" powerbi-report-id="abc123"></div>`)

.appendTo('#powerbi-fixture');

// Act

const report = powerbi.embed($reportContainer[0]);

// Assert

expect(report.config.uniqueId).toEqual(jasmine.any(String));

});

it('should get filterPaneEnabled setting from attribute from config and then attribute', function () {

// Arrange

const testUniqueId = 'fakeUniqueId';

const embedUrl = `https://embedded.powerbi.com/appTokenReportEmbed`;

const $reportContainer = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report" powerbi-report-id="abc123" powerbi-settings-filter-pane-enabled="false"></div>`)

.appendTo('#powerbi-fixture');

// Act

const report = powerbi.embed($reportContainer[0]);

// Assert

expect(report.config.settings.filterPaneEnabled).toEqual(false);

});

it('should get navContentPaneEnabled setting from attribute from config and then attribute', function () {

// Arrange

const testUniqueId = 'fakeUniqueId';

const embedUrl = `https://embedded.powerbi.com/appTokenReportEmbed`;

const $reportContainer = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report" powerbi-report-id="abc123" powerbi-settings-nav-content-pane-enabled="false"></div>`)

.appendTo('#powerbi-fixture');

// Act

const report = powerbi.embed($reportContainer[0]);

// Assert

expect(report.config.settings.navContentPaneEnabled).toEqual(false);

});

it('if component is already embedded in element re-use the existing component by calling load with the new information', function () {

// Arrange

const $element = $('<div powerbi-embed-url="https://app.powerbi.com/reportEmbed?reportId=ABC123" powerbi-type="report"></div>')

.appendTo('#powerbi-fixture');

const component = powerbi.embed($element[0]);

spyOn(component, "load");

const testConfiguration = {

accessToken: undefined,

embedUrl: 'fakeUrl',

id: 'report2'

};

// Act

const component2 = powerbi.embed($element[0], testConfiguration);

// Assert

expect(component.load).toHaveBeenCalledWith(testConfiguration);

expect(component2).toBe(component);

});

it('if report embed component was not previously created, creates an instance and return it', function () {

// Arrange

var component = $('<div powerbi-embed-url="https://app.powerbi.com/reportEmbed?reportId=ABC123" powerbi-type="report"></div>')

.appendTo('#powerbi-fixture');

// Act

var report = powerbi.embed(component[0]);

// Assert

expect(report).toBeDefined();

});

it('if dashboard embed component was not previously created, creates an instance and return it', function () {

// Arrange

var component = $('<div powerbi-embed-url="https://app.powerbi.com/dashboardEmbed?dashboardId=ABC123" powerbi-type="dashboard"></div>')

.appendTo('#powerbi-fixture');

// Act

var dashboard = powerbi.embed(component[0]);

// Assert

expect(dashboard).toBeDefined();

});

it("looks for a token first from attribute 'powerbi-access-token'", function () {

// Arrange

var embedUrl = 'https://embedded.powerbi.com/appTokenReportEmbed?reportId=ABC123';

var testToken = "fakeToken1";

var $reportContainer = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report" powerbi-access-token="${testToken}"></div>`)

.appendTo('#powerbi-fixture');

// Act

powerbi.embed($reportContainer[0]);

// Assert

var report = powerbi.get($reportContainer[0]);

var accessToken = report.config.accessToken;

expect(accessToken).toEqual(testToken);

});

it("if token is not found by attribute 'powerbi-access-token', fallback to using global", function () {

// Arrange

var embedUrl = 'https://embedded.powerbi.com/appTokenReportEmbed?reportId=ABC123';

var testToken = "fakeToken1";

var $reportContainer = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report"></div>`)

.appendTo('#powerbi-fixture');

var originalToken = powerbi.accessToken;

powerbi.accessToken = testToken;

// Act

powerbi.embed($reportContainer[0]);

// Assert

var report = powerbi.get($reportContainer[0]);

var accessToken = report.config.accessToken;

expect(accessToken).toEqual(testToken);

// Cleanup

powerbi.accessToken = originalToken;

});

describe('reports', function () {

it('creates report iframe from embedUrl', function () {

// Arrange

var embedUrl = 'https://embedded.powerbi.com/appTokenReportEmbed?reportId=ABC123';

var $reportContainer = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report"></div>`)

.appendTo('#powerbi-fixture');

// Act

let report = powerbi.embed($reportContainer[0]);

// Assert

var iframe = $reportContainer.find('iframe');

expect(iframe.length).toEqual(1);

expect(iframe.attr('src')).toEqual(embedUrl);

});

describe('findIdFromEmbedUrl', function () {

it('should return value of reportId query parameter in embedUrl', function () {

// Arrange

const testReportId = "ABC123";

const testEmbedUrl = `http://embedded.powerbi.com/appTokenReportEmbed?reportId=${testReportId}`;

// Act

const reportId = report.Report.findIdFromEmbedUrl(testEmbedUrl);

// Assert

expect(reportId).toEqual(testReportId);

});

it('should return undefinded if the query parameter is not in the url', function () {

// Arrange

const testEmbedUrl = `http://embedded.powerbi.com/appTokenReportEmbed`;

// Act

const reportId = report.Report.findIdFromEmbedUrl(testEmbedUrl);

// Assert

expect(reportId).toBeUndefined();

});

});

it('should get report id from configuration first', function () {

// Arrange

const testReportId = "ABC123";

const embedUrl = `https://embedded.powerbi.com/appTokenReportEmbed?reportId=DIFFERENTID`;

const $reportContainer = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report"></div>`)

.appendTo('#powerbi-fixture');

// Act

const report = powerbi.embed($reportContainer[0], { id: testReportId });

// Assert

expect(report.config.id).toEqual(testReportId);

});

it('should fallback to using id from attribute if not supplied in embed/load configuration', function () {

// Arrange

const testReportId = "ABC123";

const embedUrl = `https://embedded.powerbi.com/appTokenReportEmbed?reportId=DIFFERENTID`;

const $reportContainer = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report" powerbi-report-id="${testReportId}"></div>`)

.appendTo('#powerbi-fixture');

// Act

const report = powerbi.embed($reportContainer[0]);

// Assert

expect(report.config.id).toEqual(testReportId);

});

it('should fallback to using id from embedUrl if not supplied in embed/load configuration or attribute', function () {

// Arrange

const testReportId = "ABC123";

const embedUrl = `https://embedded.powerbi.com/appTokenReportEmbed?reportId=${testReportId}`;

const $reportContainer = $(`<div powerbi-embed-url="${embedUrl}" powerbi-type="report" powerbi-report-id></div>`)

.appendTo('#powerbi-fixture');

// Act

const report = powerbi.embed($reportContainer[0]);

// Assert

expect(report.config.id).toEqual(testReportId);

});

});

xdescribe('tiles', function () {

it('creates tile iframe from embedUrl', function () {

// Arrange

var embedUrl = 'https://app.powerbi.com/embed?dashboardId=D1&tileId=T1';

var $tileContainer = $('<div powerbi-embed-url="' + embedUrl + '" powerbi-type="tile"></div>')

.appendTo('#powerbi-fixture');

// Act

let tile = powerbi.embed($tileContainer[0]);

// Assert

var iframe = $tileContainer.find('iframe');

expect(iframe.length).toEqual(1);

expect(iframe.attr('src')).toEqual(embedUrl);

});

});

});

describe('reset', function () {

it('deletes the powerBiEmbed property on the element', function () {

// Arrange

const $element = $('<div></div>');

powerbi.embed($element.get(0), {

type: 'report',

embedUrl: 'fakeUrl',

id: 'fakeId',

accessToken: 'fakeToken'

});

// Act

expect((<service.IPowerBiElement>$element.get(0)).powerBiEmbed).toBeDefined();

powerbi.reset($element.get(0));

// Assert

expect((<service.IPowerBiElement>$element.get(0)).powerBiEmbed).toBeUndefined();

});

it('clears the innerHTML of the element', function () {

// Arrange

const $element = $('<div></div>');

powerbi.embed($element.get(0), {

type: 'report',

embedUrl: 'fakeUrl',

id: 'fakeReportId',

accessToken: 'fakeToken'

});

// Act

var iframe = $element.find('iframe');

expect(iframe.length).toEqual(1);

powerbi.reset($element.get(0));

// Assert

expect($element.html()).toEqual('');

});

it('removes the powerbi instance from the list of embeds', function () {

// Arrange

const $element = $('<div></div>');

const testEmbedConfig = {

type: 'report',

embedUrl: 'fakeUrl',

id: 'fakeReportId',

accessToken: 'fakeToken',

uniqueId: 'fakeUniqeId'

};

powerbi.embed($element.get(0), testEmbedConfig);

// Act

const report = powerbi.find(testEmbedConfig.uniqueId);

expect(report).toBeDefined();

powerbi.reset($element.get(0));

// Assert

const report2 = powerbi.find(testEmbedConfig.uniqueId);

expect(report2).toBeUndefined();

});

});

});

describe('embed', function () {

let powerbi: service.Service;

let $element: JQuery;

let $container: JQuery;

let $iframe: JQuery;

beforeAll(function () {

powerbi = new service.Service(factories.hpmFactory, factories.wpmpFactory, factories.routerFactory);

powerbi.accessToken = 'ABC123';

$element = $('<div id="powerbi-fixture"></div>').appendTo(document.body);

});

beforeEach(function () {

$container = $('<div powerbi-embed-url="https://app.powerbi.com/reportEmbed?reportId=ABC123" powerbi-type="report"></div>')

.appendTo('#powerbi-fixture');

powerbi.embed($container[0]);

$iframe = $container.find('iframe');

});

afterEach(function () {

$element.empty();

});

afterAll(function () {

$element.remove();

powerbi.wpmp.stop();

});

describe('iframe', function () {

it('has a src', function () {

expect($iframe.attr('src').length).toBeGreaterThan(0);

});

it('disables scrollbars by default', function () {

expect($iframe.attr('scrolling')).toEqual('no');

});

it('sets width/height to 100%', function () {

expect($iframe[0].style.width).toEqual('100%');

expect($iframe[0].style.height).toEqual('100%');

});

});

describe('fullscreen', function () {

it('sets the iframe as the fullscreen element', function () {

var report = powerbi.get($container[0]);

report.fullscreen();

expect(document.webkitFullscreenElement === $iframe[0]);

});

});

describe('exitFullscreen', function () {

it('clears the iframe fullscreen element', function () {

var report = powerbi.get($container[0]);

report.fullscreen();

report.exitFullscreen();

expect(document.webkitFullscreenElement !== $iframe[0]);

});

});

});

describe('Protocol', function () {

let hpm: Hpm.HttpPostMessage;

let wpmp: Wpmp.WindowPostMessageProxy;

let iframe: HTMLIFrameElement;

let iframeHpm: Hpm.HttpPostMessage;

let iframeLoaded: Promise<void>;

let handler: Wpmp.IMessageHandler;

let spyHandler: {

test: jasmine.Spy,

handle: jasmine.Spy

};

beforeAll(function () {

const iframeSrc = "base/test/utility/noop.html";

const $iframe = $(`<iframe src="${iframeSrc}"></iframe>`).appendTo(document.body);

iframe = <HTMLIFrameElement>$iframe.get(0);

// Register Iframe side

iframeHpm = setupEmbedMockApp(iframe.contentWindow, window, logMessages, 'ProtocolMockAppWpmp');

// Register SDK side WPMP

wpmp = factories.wpmpFactory('HostProxyDefaultNoHandlers', logMessages, iframe.contentWindow);

hpm = factories.hpmFactory(wpmp, iframe.contentWindow, 'testVersion');

const router = factories.routerFactory(wpmp);

router.post('/reports/:uniqueId/events/:eventName', (req, res) => {

handler.handle(req);

res.send(202);

});

router.post('/reports/:uniqueId/pages/:pageName/events/:eventName', (req, res) => {

handler.handle(req);

res.send(202);

});

handler = {

test: jasmine.createSpy("testSpy").and.returnValue(true),

handle: jasmine.createSpy("handleSpy").and.callFake(function (message: any) {

message.handled = true;

return message;

})

};

spyHandler = <any>handler;

// wpmp.addHandler(handler);

iframeLoaded = new Promise<void>((resolve, reject) => {

iframe.addEventListener('load', () => {

resolve(null);

});

});

});

afterAll(function () {

wpmp.stop();

});

beforeEach(() => {

// empty

});

afterEach(function () {

spyHandler.test.calls.reset();

spyHandler.handle.calls.reset();

});

describe('HPM-to-MockApp', function () {

describe('notfound', function () {

it('GET request to uknown url returns 404 Not Found', function (done) {

iframeLoaded

.then(() => {

hpm.get<any>('route/that/does/not/exist')

.catch(response => {

expect(response.statusCode).toEqual(404);

done();

});

});

});

it('POST request to uknown url returns 404 Not Found', function (done) {

iframeLoaded

.then(() => {

hpm.post<any>('route/that/does/not/exist', null)

.catch(response => {

expect(response.statusCode).toEqual(404);

done();

});

});

});

it('PUT request to uknown url returns 404 Not Found', function (done) {

iframeLoaded

.then(() => {

hpm.put<any>('route/that/does/not/exist', null)

.catch(response => {

expect(response.statusCode).toEqual(404);

done();

});

});

});

it('PATCH request to uknown url returns 404 Not Found', function (done) {

iframeLoaded

.then(() => {

hpm.patch<any>('route/that/does/not/exist', null)

.catch(response => {

expect(response.statusCode).toEqual(404);

done();

});

});

});

it('DELETE request to uknown url returns 404 Not Found', function (done) {

iframeLoaded

.then(() => {

hpm.delete<any>('route/that/does/not/exist')

.catch(response => {

expect(response.statusCode).toEqual(404);

done();

});

});

});

});

describe('load', function () {

describe('report', function () {

it('POST /report/load returns 400 if the request is invalid', function (done) {

// Arrange

const testData = {

uniqueId: 'uniqueId',

load: {

reportId: "fakeId",

accessToken: "fakeToken",

options: {

}

}

};

iframeLoaded

.then(() => {

spyApp.validateReportLoad.and.returnValue(Promise.reject(null));

// Act

hpm.post<models.IError>('/report/load', testData.load, { uid: testData.uniqueId })

.then(() => {

expect(false).toBe(true);

spyApp.validateReportLoad.calls.reset();

done();

})

.catch(response => {

// Assert

expect(spyApp.validateReportLoad).toHaveBeenCalledWith(testData.load);

expect(spyApp.reportLoad).not.toHaveBeenCalledWith(testData.load);

expect(response.statusCode).toEqual(400);

// Cleanup

spyApp.validateReportLoad.calls.reset();

done();

});

});

});

it('POST /report/load returns 202 if the request is valid', function (done) {

// Arrange

const testData = {

load: {

reportId: "fakeId",

accessToken: "fakeToken",

options: {

}

}

};

iframeLoaded

.then(() => {

spyApp.validateReportLoad.and.returnValue(Promise.resolve(null));

// Act

hpm.post<void>('/report/load', testData.load)

.then(response => {

// Assert

expect(spyApp.validateReportLoad).toHaveBeenCalledWith(testData.load);

expect(spyApp.reportLoad).toHaveBeenCalledWith(testData.load);

expect(response.statusCode).toEqual(202);

// Cleanup

spyApp.validateReportLoad.calls.reset();

spyApp.reportLoad.calls.reset();

done();

});

});

});

it('POST /report/load causes POST /reports/:uniqueId/events/loaded', function (done) {

// Arrange

const testData = {

uniqueId: 'uniqueId',

load: {

reportId: "fakeId",

accessToken: "fakeToken",

options: {

navContentPaneEnabled: false

}

},

};

const testExpectedEvent = {

method: 'POST',

url: `/reports/${testData.uniqueId}/events/loaded`,

body: {

initiator: 'sdk'

}

};

iframeLoaded

.then(() => {

spyApp.reportLoad.and.returnValue(Promise.resolve(testData.load));

// Act

hpm.post<void>('/report/load', testData.load, { uid: testData.uniqueId })

.then(response => {

setTimeout(() => {

// Assert

expect(spyApp.validateReportLoad).toHaveBeenCalledWith(testData.load);

expect(spyApp.reportLoad).toHaveBeenCalledWith(testData.load);

expect(spyHandler.handle).toHaveBeenCalledWith(jasmine.objectContaining(testExpectedEvent));

// Cleanup

spyApp.validateReportLoad.calls.reset();

spyApp.reportLoad.calls.reset();

done();

});

});

});

});

it('POST /report/load causes POST /reports/:uniqueId/events/error', function (done) {

// Arrange

const testData = {

uniqueId: 'uniqueId',

load: {

reportId: "fakeId",

accessToken: "fakeToken",

options: {

navContentPaneEnabled: false

}

},

error: {

message: "error message"

}

};

const testExpectedEvent = {

method: 'POST',

url: `/reports/${testData.uniqueId}/events/error`,

body: testData.error

};

iframeLoaded

.then(() => {

spyApp.reportLoad.and.returnValue(Promise.reject(testData.error));

// Act

hpm.post<void>('/report/load', testData.load, { uid: testData.uniqueId })

.then(response => {

setTimeout(() => {

// Assert

expect(spyApp.validateReportLoad).toHaveBeenCalledWith(testData.load);

expect(spyApp.reportLoad).toHaveBeenCalledWith(testData.load);

expect(spyHandler.handle).toHaveBeenCalledWith(jasmine.objectContaining(testExpectedEvent));

// Cleanup

spyApp.validateReportLoad.calls.reset();

spyApp.reportLoad.calls.reset();

done();

});

});

});

});

});

describe('dashboard', function () {

it('POST /dashboard/load returns 202 if the request is valid', function (done) {

// Arrange

const testData = {

load: {

dashboardId: "fakeId",

accessToken: "fakeToken",

options: {

}

}

};

iframeLoaded

.then(() => {

spyApp.validateDashboardLoad.and.returnValue(Promise.resolve(null));

// Act

hpm.post<void>('/dashboard/load', testData.load)

.then(response => {

// Assert

expect(spyApp.validateDashboardLoad).toHaveBeenCalledWith(testData.load);

expect(spyApp.dashboardLoad).toHaveBeenCalledWith(testData.load);

expect(response.statusCode).toEqual(202);

// Cleanup

spyApp.validateDashboardLoad.calls.reset();

spyApp.dashboardLoad.calls.reset();

done();

});

});

});

it('POST /dashboard/load returns 400 if the request is invalid', function (done) {

// Arrange

const testData = {

uniqueId: 'uniqueId',

load: {

dashboardId: "fakeId",

accessToken: "fakeToken",

options: {

}

}

};

iframeLoaded

.then(() => {

spyApp.validateDashboardLoad.and.returnValue(Promise.reject(null));

// Act

hpm.post<models.IError>('/dashboard/load', testData.load, { uid: testData.uniqueId })

.then(() => {

expect(false).toBe(true);

spyApp.validateDashboardLoad.calls.reset();

done();

})

.catch(response => {

// Assert

expect(spyApp.validateDashboardLoad).toHaveBeenCalledWith(testData.load);

expect(spyApp.dashboardLoad).not.toHaveBeenCalledWith(testData.load);

expect(response.statusCode).toEqual(400);

// Cleanup

spyApp.validateDashboardLoad.calls.reset();

done();

});

});

});

});

});

describe('pages', function () {

it('GET /report/pages returns 200 with body as array of pages', function (done) {