730 lines
28 KiB
JavaScript
730 lines
28 KiB
JavaScript
describe("Test Controller LaunchActionController", function() {
|
|
'use strict';
|
|
|
|
var scope, systemAlertService, $httpBackend, $log, $e, $q, rootScope, events, $timeout,
|
|
createController, callback, objectValueMapperService, screenConfigurationModel, actionList, expressionEvaluatorService;
|
|
beforeEach(module('myitsmApp', 'templates'));
|
|
beforeEach(inject(function ($rootScope, _$httpBackend_, $controller, $injector, _screenConfigurationModel_, _systemAlertService_, _$log_, _$q_, _objectValueMapperService_, _expressionEvaluatorService_, _events_, _$timeout_) {
|
|
scope = $rootScope.$new();
|
|
rootScope = $rootScope;
|
|
var getLocale = function () {
|
|
return readJSON('scripts/app/i18n/resources-locale_en.json');
|
|
};
|
|
|
|
$httpBackend = _$httpBackend_;
|
|
|
|
$httpBackend.whenGET(/^scripts\/app\/i18n\/resources-locale_en.*$/).respond(200, getLocale());
|
|
$httpBackend.whenGET('/smartit/rest/v2/metadata?type=incident').respond(200, [{items: []}]);
|
|
$httpBackend.when('POST', '/smartit/rest/v3/action/execute').respond(200);
|
|
$httpBackend.whenGET('/smartit/rest/serverstates').respond(200);
|
|
$httpBackend.whenGET('/smartit/rest/sessionstatus?getLicenseKey=true').respond(200);
|
|
$httpBackend.whenGET('views/dashboard/index.html').respond(200);
|
|
$httpBackend.whenGET('/smartit/rest/v2/metadata?type=global').respond(200, readJSON('mocks/metadata-global.json'));
|
|
$httpBackend.whenGET('/smartit/restapi/person/supportgroupperson').respond(200);
|
|
|
|
screenConfigurationModel = _screenConfigurationModel_;
|
|
systemAlertService = _systemAlertService_;
|
|
expressionEvaluatorService = _expressionEvaluatorService_;
|
|
$log = _$log_;
|
|
$q = _$q_;
|
|
objectValueMapperService = _objectValueMapperService_;
|
|
events = _events_;
|
|
$timeout = _$timeout_;
|
|
|
|
var deferred = $q.defer(),
|
|
response = {},
|
|
actionResponse = new ActionVO();
|
|
actionList = [
|
|
{
|
|
"resource": "incident",
|
|
"actionType": "provider",
|
|
"actionName": "PA_CHG_OTB_TO_OTB",
|
|
"supportedPlatforms": [
|
|
"web"
|
|
],
|
|
"url": "",
|
|
"labels": {
|
|
"default": "PA_CHG_OTBTO_OTB_Label"
|
|
},
|
|
"sequenceNo": 1,
|
|
"scope": {},
|
|
"target": "new",
|
|
"mode": "both",
|
|
"isOpen": false,
|
|
"delete": false,
|
|
"screenId": "AGGAA5V0HG8SIAOSYVXNABCS8RNIK3",
|
|
"templateId": "IDGAA5V0HG8OSAP7DK8QP6GLRPETRX",
|
|
"actionOrder": "",
|
|
"mappings": [
|
|
{
|
|
"type": "input-ticket",
|
|
"mappedFieldId": 1000000000,
|
|
"mappedFieldValue": "id"
|
|
},
|
|
{
|
|
"type": "output",
|
|
"mappedFieldId": 1000000151,
|
|
"mappedFieldValue": "desc"
|
|
}
|
|
],
|
|
"isExpression": false,
|
|
"expressions": [
|
|
{
|
|
"resource": "incident",
|
|
"executeOn": "On Field Value Change",
|
|
"condition": "$priority == 'High'",
|
|
"sequenceNo": 1
|
|
}
|
|
],
|
|
"mappedFields": [],
|
|
"entryId": "000000000000001",
|
|
"formName": "CHG:Infrastructure Change",
|
|
"isSynchronous": true,
|
|
"id": "AGGAA5V0HG8OSAP7F4UMP6I6DLFQIP",
|
|
"label": "PA_CHG_OTBTO_OTB_Label"
|
|
},
|
|
{
|
|
"resource": "incident",
|
|
"actionType": "provider",
|
|
"actionName": "PA_CHG_OTB_TO_OTB",
|
|
"supportedPlatforms": [
|
|
"web"
|
|
],
|
|
"url": "",
|
|
"labels": {
|
|
"default": "PA_CHG_OTBTO_OTB_Label2"
|
|
},
|
|
"sequenceNo": 1,
|
|
"scope": {},
|
|
"target": "new",
|
|
"mode": "both",
|
|
"isOpen": false,
|
|
"delete": false,
|
|
"screenId": "AGGAA5V0HG8SIAOSYVXNABCS8RNIK2",
|
|
"templateId": "IDGAA5V0HG8OSAP7DK8QP6GLRPETRX",
|
|
"actionOrder": "",
|
|
"mappings": [
|
|
{
|
|
"type": "input-ticket",
|
|
"mappedFieldId": 1000000151,
|
|
"mappedFieldValue": "desc"
|
|
},
|
|
{
|
|
"type": "output",
|
|
"mappedFieldId": 1000000150,
|
|
"mappedFieldValue": "middleintial"
|
|
}
|
|
],
|
|
"isExpression": false,
|
|
"expressions": [
|
|
{
|
|
"resource": "incident",
|
|
"executeOn": "On Field Value Change",
|
|
"condition": "$desc == 'description'",
|
|
"sequenceNo": 2
|
|
}
|
|
],
|
|
"mappedFields": [],
|
|
"entryId": "000000000000002",
|
|
"formName": "CHG:Infrastructure Change",
|
|
"isSynchronous": true,
|
|
"id": "AGGAA5V0HG8OSAP7F4UMP6I6DLABCD",
|
|
"label": "PA_CHG_OTBTO_OTB_Label2"
|
|
}
|
|
];
|
|
|
|
scope.context = new TicketVO();
|
|
|
|
scope.launchActionCallback = function() {};
|
|
|
|
scope.context.type = EntityVO.TYPE_INCIDENT;
|
|
scope.context.id = "cid";
|
|
|
|
callback = function() {};
|
|
|
|
spyOn(screenConfigurationModel, 'loadActionsNew').and.callFake(function () {
|
|
screenConfigurationModel.actionList = actionList;
|
|
deferred.resolve(actionResponse);
|
|
return deferred.promise;
|
|
});
|
|
|
|
spyOn(screenConfigurationModel, 'getTemplateById').and.callFake(function () {
|
|
deferred.resolve(response);
|
|
return deferred.promise;
|
|
});
|
|
|
|
spyOn(screenConfigurationModel, 'executeProviderAction').and.callFake(function () {
|
|
deferred.resolve(response);
|
|
return deferred.promise;
|
|
});
|
|
|
|
spyOn(objectValueMapperService, 'setFieldActionMapping');
|
|
spyOn(objectValueMapperService, 'addToProviderActionExpressionMapper');
|
|
|
|
createController = function () {
|
|
return $controller('LaunchActionController', {
|
|
'$scope': scope,
|
|
'$log' : $log
|
|
});
|
|
};
|
|
|
|
scope.providerActionsList = [];
|
|
createController();
|
|
scope.$apply();
|
|
}));
|
|
|
|
it(' should run launchAction method ',function(){
|
|
$e = document.createEvent("HTMLEvents");
|
|
scope.launchActionCallback = function() {};
|
|
scope.launchAction ({id:'1234213XSSD',name: 'test'},'provider',$e);
|
|
scope.launchAction ({id:'1234213XSSD',name: 'test'},'launch',$e);
|
|
scope.context.type = EntityVO.TYPE_WORKORDER;
|
|
scope.launchAction ({id:'1234213XSSD',name: 'test'},'provider',$e);
|
|
});
|
|
|
|
it(' should run showEditor method ',function(){
|
|
$e = document.createEvent("HTMLEvents");
|
|
var params = {}, ticketObj = new TicketVO(), contextId = 'w23sdfs';
|
|
scope.showEditor (callback,params,ticketObj, contextId );
|
|
});
|
|
|
|
|
|
it(' should run displaypromptModal method ',function(){
|
|
var params = {prompt:[{mappedFieldId:234234}]}, ticketObj = new TicketVO(), contextId = 'w23sdfs', templateId= 'sdf23423423';
|
|
scope.displaypromptModal (callback, params,templateId,ticketObj,contextId);
|
|
});
|
|
|
|
describe('Input prompt dialog', function () {
|
|
var characterField, numberField, cBoxField, dropDownField, radioField, dateOnlyField, dateTimeField,
|
|
timeOnlyField, customTypeField;
|
|
|
|
function removeModalContent($promptModal) {
|
|
$promptModal.scope().cancelExecution();
|
|
$promptModal.scope().$digest();
|
|
$promptModal.remove();
|
|
}
|
|
|
|
beforeEach(inject(function ($q, ticketModel) {
|
|
characterField = new FieldVO().build({
|
|
name: 'characterField',
|
|
type: FieldVO.prototype.CHARACTER_FIELD,
|
|
dataType: FieldVO.prototype.DATA_TYPE_TEXT,
|
|
id: 'text'
|
|
});
|
|
numberField = new FieldVO().build({
|
|
name: 'numberField',
|
|
type: FieldVO.prototype.NUMBER_FIELD,
|
|
dataType: FieldVO.prototype.DATA_TYPE_INTEGER,
|
|
id: 'number'
|
|
});
|
|
cBoxField = new FieldVO().build({
|
|
name: 'cBoxField',
|
|
type: FieldVO.prototype.STATIC_SELECTION_FIELD,
|
|
dataType: FieldVO.prototype.DATA_TYPE_CHECKBOX,
|
|
id: 'cbox',
|
|
options: [{ index: 0, name: 'confirm', label: 'Confirm' }]
|
|
});
|
|
dropDownField = new FieldVO().build({
|
|
name: 'dropDownField',
|
|
type: FieldVO.prototype.STATIC_SELECTION_FIELD,
|
|
dataType: FieldVO.prototype.DATA_TYPE_DROPDOWN,
|
|
id: 'dropdown',
|
|
ootb: true,
|
|
options: [{ index: 0, name: 'opt1', label: 'Option 1' }, { index: 1, name: 'opt2', label: 'Option 2' }]
|
|
});
|
|
radioField = new FieldVO().build({
|
|
name: 'radioField',
|
|
type: FieldVO.prototype.STATIC_SELECTION_FIELD,
|
|
dataType: FieldVO.prototype.DATA_TYPE_RADIO,
|
|
id: 'cbox',
|
|
ootb: true,
|
|
options: [{ index: 0, name: 'yes', label: 'Yes' }, { index: 1, name: 'no', label: 'No' }]
|
|
});
|
|
dateOnlyField = new FieldVO().build({
|
|
name: 'dateOnlyField',
|
|
type: FieldVO.prototype.DATE_FIELD,
|
|
dataType: FieldVO.prototype.DATA_TYPE_DATE,
|
|
id: 'date'
|
|
});
|
|
dateTimeField = new FieldVO().build({
|
|
name: 'dateTimeField',
|
|
type: FieldVO.prototype.DATE_TIME_FIELD,
|
|
dataType: FieldVO.prototype.DATA_TYPE_DATE_TIME,
|
|
id: 'dateTime'
|
|
});
|
|
timeOnlyField = new FieldVO().build({
|
|
name: 'timeOnlyField',
|
|
type: FieldVO.prototype.DATE_TIME_FIELD,
|
|
dataType: FieldVO.prototype.DATA_TYPE_TIME,
|
|
id: 'time'
|
|
});
|
|
customTypeField = new FieldVO().build({
|
|
name: 'customTypeField',
|
|
type: 'customType',
|
|
dataType: 'customDataType',
|
|
id: 'custom'
|
|
});
|
|
|
|
$httpBackend.whenGET(/smartit\/rest\/v2\/incident/).respond(200, [{
|
|
items: [{
|
|
id: 'incidentId',
|
|
type: EntityVO.TYPE_INCIDENT
|
|
}]
|
|
}]);
|
|
$httpBackend.whenGET(/smartit\/rest\/attachment\/info\/incident/).respond(200, [{ items: [] }]);
|
|
|
|
spyOn(ticketModel, 'getTicket').and.callFake(function () {
|
|
var fakeIncident = new IncidentVO().build({
|
|
id: 'test',
|
|
type: EntityVO.TYPE_INCIDENT,
|
|
accessMappings: {
|
|
detailsEditAllowed:true
|
|
}
|
|
});
|
|
|
|
ticketModel.cache['test'] = fakeIncident;
|
|
|
|
return $q.when(fakeIncident);
|
|
});
|
|
|
|
// jasmine.clock().install();
|
|
}));
|
|
|
|
afterEach(function () {
|
|
var $promptDialog = angular.element(document).find('.provider-user-prompt');
|
|
|
|
$promptDialog.remove();
|
|
// jasmine.clock().uninstall()
|
|
});
|
|
|
|
it('should open modal with different type of inputs', function () {
|
|
var promptParams = [characterField, numberField, cBoxField, dropDownField, radioField, dateOnlyField,
|
|
dateTimeField, timeOnlyField, customTypeField]
|
|
.map(function (field) {
|
|
return {
|
|
type: 'input',
|
|
defaultValue: '',
|
|
mappedFieldId: field.id,
|
|
mappedFieldName: field.name,
|
|
mappedField: field
|
|
}
|
|
});
|
|
|
|
scope.showEditor(callback, { prompt: promptParams }, { resource: EntityVO.TYPE_INCIDENT }, 'incidentId');
|
|
scope.$apply();
|
|
|
|
var $promptModal = angular.element(document).find('.provider-user-prompt'),
|
|
$textInput = $promptModal.find('input[name="characterField"]'),
|
|
$customTypeField = $promptModal.find('input[name="customTypeField"]'),
|
|
$numberInput = $promptModal.find('input[name="numberField"]'),
|
|
$cBoxField = $promptModal.find('input[name="cBoxField"]'),
|
|
$dropDownField = $promptModal.find('.select-custom-dropdown'),
|
|
$radioField = $promptModal.find('.custom-field__radio'),
|
|
$dateTimeField = $promptModal.find('.custom-field__date_time_container'),
|
|
$dateOnlyField = $promptModal.find('.custom-field__date_single'),
|
|
$timeOnlyField = $promptModal.find('.custom-field__time_single');
|
|
|
|
expect($promptModal.length).toEqual(1);
|
|
expect($textInput[0]).toBeDefined();
|
|
expect($numberInput[0]).toBeDefined();
|
|
expect($customTypeField[0]).toBeDefined();
|
|
expect($cBoxField[0]).toBeDefined();
|
|
expect($dropDownField[0]).toBeDefined();
|
|
expect($radioField[0]).toBeDefined();
|
|
expect($dateTimeField[0]).toBeDefined();
|
|
expect($dateOnlyField[0]).toBeDefined();
|
|
expect($timeOnlyField[0]).toBeDefined();
|
|
expect($numberInput[0].type).toBe('number');
|
|
expect($customTypeField[0].type).toBe('text');
|
|
expect($cBoxField[0].type).toBe('checkbox');
|
|
expect($radioField.find('input[name="radioField"]').length).toEqual(2);
|
|
expect($radioField.find('input[name="radioField"]')[0].type).toBe('radio');
|
|
});
|
|
|
|
it('should set default value for text and number fields', function () {
|
|
var promptParams = [characterField, numberField, customTypeField].map(function (field) {
|
|
var defaultValue;
|
|
|
|
if (field.isTextField()) {
|
|
defaultValue = 'text123';
|
|
} else if (field.isNumberField()) {
|
|
defaultValue = 100;
|
|
} else {
|
|
defaultValue = 'custom123';
|
|
}
|
|
|
|
return {
|
|
type: 'input',
|
|
defaultValue: defaultValue,
|
|
mappedFieldId: field.id,
|
|
mappedFieldName: field.name,
|
|
mappedField: field
|
|
}
|
|
});
|
|
|
|
scope.showEditor(callback, { prompt: promptParams }, { resource: EntityVO.TYPE_INCIDENT }, 'incidentId');
|
|
scope.$apply();
|
|
|
|
var $promptModal = angular.element(document).find('.provider-user-prompt'),
|
|
$textInput = $promptModal.find('input[name="characterField"]'),
|
|
$customTypeField = $promptModal.find('input[name="customTypeField"]'),
|
|
$numberInput = $promptModal.find('input[name="numberField"]');
|
|
|
|
expect($textInput[0].value).toBe('text123');
|
|
expect($customTypeField[0].value).toBe('custom123');
|
|
expect($numberInput[0].value).toBe('100');
|
|
});
|
|
|
|
it('should set default value for dropdown and radio fields', function () {
|
|
var promptParams = [dropDownField, radioField].map(function (field) {
|
|
return {
|
|
type: 'input',
|
|
defaultValue: 'wrongValue',
|
|
mappedFieldId: field.id,
|
|
mappedFieldName: field.name,
|
|
mappedField: field
|
|
}
|
|
});
|
|
|
|
scope.showEditor(callback, { prompt: promptParams }, { resource: EntityVO.TYPE_INCIDENT }, 'incidentId');
|
|
scope.$apply();
|
|
|
|
var $promptModal = angular.element(document).find('.provider-user-prompt'),
|
|
$dropdownInputButton = $promptModal.find('.select-custom-dropdown .dropdown-input__button'),
|
|
$radioField = $promptModal.find('.custom-field__radio'),
|
|
$radioFieldInputs = $radioField.find('input[type="radio"]');
|
|
|
|
expect(dropDownField.value).toBe(null);
|
|
expect($dropdownInputButton.text()).not.toEqual('wrongValue');
|
|
expect($radioFieldInputs.length).toEqual(2);
|
|
expect($radioFieldInputs.find('input:checked').length).toEqual(0);
|
|
|
|
promptParams = [dropDownField, radioField].map(function (field) {
|
|
var defaultValue = field.options[0].label; // name and index properties are valid for defaultValue as well
|
|
|
|
return {
|
|
type: 'input',
|
|
defaultValue: defaultValue,
|
|
mappedFieldId: field.id,
|
|
mappedFieldName: field.name,
|
|
mappedField: field
|
|
}
|
|
});
|
|
|
|
removeModalContent($promptModal);
|
|
|
|
scope.showEditor(callback, { prompt: promptParams }, { resource: EntityVO.TYPE_INCIDENT }, 'incidentId2');
|
|
scope.$apply();
|
|
|
|
|
|
var $promptModal2 = angular.element(document).find('.provider-user-prompt');
|
|
$dropdownInputButton = $promptModal2.find('.select-custom-dropdown .dropdown-input__button');
|
|
$radioField = $promptModal2.find('.custom-field__radio');
|
|
|
|
var $checkedRadioFieldInputs = $radioField.find('input[type="radio"]:checked');
|
|
|
|
expect(dropDownField.value).toBe(dropDownField.options[0].name);
|
|
expect($dropdownInputButton.text().trim()).toEqual(dropDownField.options[0].label);
|
|
expect($checkedRadioFieldInputs.length).toEqual(1);
|
|
});
|
|
|
|
it('should set for checkbox field', function () {
|
|
var promptParams = [{
|
|
type: 'input',
|
|
defaultValue: 'wrongValue',
|
|
mappedFieldId: cBoxField.id,
|
|
mappedFieldName: cBoxField.name,
|
|
mappedField: cBoxField
|
|
}];
|
|
|
|
scope.showEditor(callback, { prompt: promptParams }, { resource: EntityVO.TYPE_INCIDENT }, 'incidentId');
|
|
scope.$apply();
|
|
|
|
var $promptModal = angular.element(document).find('.provider-user-prompt'),
|
|
cbox = $promptModal.find('input[type="checkbox"]');
|
|
|
|
expect(cbox.length).toEqual(1);
|
|
expect(cbox.prop('checked')).toBe(false);
|
|
|
|
removeModalContent($promptModal);
|
|
|
|
promptParams = [{
|
|
type: 'input',
|
|
defaultValue: 'true',
|
|
mappedFieldId: cBoxField.id,
|
|
mappedFieldName: cBoxField.name,
|
|
mappedField: cBoxField
|
|
}];
|
|
|
|
scope.showEditor(callback, { prompt: promptParams }, { resource: EntityVO.TYPE_INCIDENT }, 'incidentId');
|
|
scope.$apply();
|
|
|
|
var $promptModal2 = angular.element(document).find('.provider-user-prompt'),
|
|
cbox2 = $promptModal2.find('input[type="checkbox"]');
|
|
|
|
expect(cbox2.prop('checked')).toBe(true);
|
|
|
|
removeModalContent($promptModal2);
|
|
|
|
promptParams = [{
|
|
type: 'input',
|
|
defaultValue: 'checked',
|
|
mappedFieldId: cBoxField.id,
|
|
mappedFieldName: cBoxField.name,
|
|
mappedField: cBoxField
|
|
}];
|
|
|
|
scope.showEditor(callback, { prompt: promptParams }, { resource: EntityVO.TYPE_INCIDENT }, 'incidentId');
|
|
scope.$apply();
|
|
|
|
var $promptModal3 = angular.element(document).find('.provider-user-prompt'),
|
|
cbox3 = $promptModal3.find('input[type="checkbox"]');
|
|
|
|
expect(cbox3.prop('checked')).toBe(true);
|
|
|
|
removeModalContent($promptModal3);
|
|
|
|
promptParams = [{
|
|
type: 'input',
|
|
defaultValue: 0,
|
|
mappedFieldId: cBoxField.id,
|
|
mappedFieldName: cBoxField.name,
|
|
mappedField: cBoxField
|
|
}];
|
|
|
|
scope.showEditor(callback, { prompt: promptParams }, { resource: EntityVO.TYPE_INCIDENT }, 'incidentId');
|
|
scope.$apply();
|
|
|
|
expect(cbox3.prop('checked')).toBe(true);
|
|
});
|
|
|
|
it('should set default value for date and date-time field', function () {
|
|
var promptParams = [
|
|
{
|
|
type: 'input',
|
|
defaultValue: '25-01-2018', // wrong date string
|
|
mappedFieldId: dateOnlyField.id,
|
|
mappedFieldName: dateOnlyField.name,
|
|
mappedField: dateOnlyField
|
|
}, {
|
|
type: 'input',
|
|
defaultValue: '25-01-2018', // wrong date string
|
|
mappedFieldId: dateTimeField.id,
|
|
mappedFieldName: dateTimeField.name,
|
|
mappedField: dateTimeField
|
|
}
|
|
];
|
|
|
|
scope.showEditor(callback, { prompt: promptParams }, { resource: EntityVO.TYPE_INCIDENT }, 'incidentId');
|
|
scope.$apply();
|
|
|
|
expect(dateOnlyField.value).toBe(null);
|
|
expect(dateTimeField.value).toBe(null);
|
|
|
|
var $promptModal = angular.element(document).find('.provider-user-prompt');
|
|
|
|
removeModalContent($promptModal);
|
|
|
|
promptParams[0].defaultValue = '29 January 2018';
|
|
promptParams[1].defaultValue = '1/29/2018';
|
|
|
|
scope.showEditor(callback, { prompt: promptParams }, { resource: EntityVO.TYPE_INCIDENT }, 'incidentId');
|
|
scope.$apply();
|
|
|
|
expect(dateOnlyField.value.valueOf()).toBe(moment('29 January 2018').valueOf());
|
|
expect(dateTimeField.value.valueOf()).toBe(moment('1/29/2018').valueOf());
|
|
|
|
var $promptModal2 = angular.element(document).find('.provider-user-prompt');
|
|
|
|
removeModalContent($promptModal2);
|
|
|
|
promptParams[0].defaultValue = 1516860000000;
|
|
promptParams[1].defaultValue = '1516860000000';
|
|
|
|
scope.showEditor(callback, { prompt: promptParams }, { resource: EntityVO.TYPE_INCIDENT }, 'incidentId');
|
|
scope.$apply();
|
|
|
|
expect(dateOnlyField.value.valueOf()).toBe(1516860000000);
|
|
expect(dateTimeField.value.valueOf()).toBe(1516860000000);
|
|
});
|
|
});
|
|
|
|
|
|
it(' should run getInputParams method ',function(){
|
|
var actionObj = new ActionVO(), ticketObj = new TicketVO(), contextId = 'w23sdfs';
|
|
actionObj.mappings = [{mappedFieldValue:'xvyz', type:'input-prompt', mappedFieldId: '23423423'},{mappedFieldValue:'abcd', type:'input-ticket', mappedFieldId: '23423423'},{mappedFieldValue:'test', type:'input-default', mappedFieldId: '23423423'}, {mappedFieldValue:'sdfds', type:'output', mappedFieldId: '23423423'}];
|
|
var test = scope.getInputParams (actionObj,ticketObj,callback, contextId);
|
|
expect(test).toBeDefined();
|
|
});
|
|
|
|
it(' should run executeActionCallback method ',function(){
|
|
var params = {}, actionObj = new ActionVO(), contextId = 'w23sdfs';
|
|
scope.executeActionCallback(params,actionObj, contextId);
|
|
actionObj.isSynchronous = true;
|
|
scope.executeActionCallback(params,actionObj, contextId);
|
|
scope.$apply();
|
|
});
|
|
|
|
it(' should run checkForOutputMapping method ',function(){
|
|
var actionObj = new ActionVO();
|
|
actionObj.mappings = [{mappedFieldValue:'xvyz', type:'input-prompt', mappedFieldId: '23423423'},{mappedFieldValue:'abcd', type:'input-ticket', mappedFieldId: '23423423'},{mappedFieldValue:'test', type:'input-default', mappedFieldId: '23423423'}, {mappedFieldValue:'sdfds', type:'output', mappedFieldId: '23423423'}];
|
|
var test = scope.checkForOutputMapping (actionObj);
|
|
expect(test).toBeTruthy();
|
|
});
|
|
|
|
it('should run launchActionFromExpression method',function(){
|
|
var actionList = [];
|
|
scope.launchActionFromExpression(actionList);
|
|
actionList = [{action: {id:'1234213XSSD',name: 'test'}, actionId: '1234213XSSD',expression: 'status == "Assigned"'}];
|
|
scope.launchActionFromExpression(actionList);
|
|
});
|
|
|
|
it('should run launchAction method from action expression',function(){
|
|
var calledFromActionExpression = true;
|
|
scope.launchAction({id:'1234213XSSD',name: 'test', isSynchronous: true}, 'provider', null, calledFromActionExpression);
|
|
});
|
|
|
|
it('should extract provider action expression to expression mapper on ticket load',function() {
|
|
|
|
expect(scope.AssociateActionLists).toBe(screenConfigurationModel.actionList);
|
|
expect(scope.actionLists).toBe(screenConfigurationModel.actionList);
|
|
expect(objectValueMapperService.setFieldActionMapping).toHaveBeenCalledWith(scope.fieldActionMapping, EntityVO.TYPE_INCIDENT);
|
|
expect(objectValueMapperService.addToProviderActionExpressionMapper).toHaveBeenCalledWith(scope.AssociateActionLists[0].expressions[0].condition, scope.AssociateActionLists[0]);
|
|
});
|
|
|
|
it('should trigger PROVIDER_ACTION events handler and should launch action from expression if provider action expression condition is matched in case of only one provider action',function() {
|
|
var data = [{
|
|
actionId: "AGGAA5V0HG8OSAP7F4UMP6I6DLFQIP",
|
|
expression: "$priority == 'High'",
|
|
action: actionList[0]
|
|
}], providerActionOutput = {1000000151: 'description'};
|
|
spyOn(objectValueMapperService, 'getProviderActionsList').and.returnValue(data);
|
|
spyOn(expressionEvaluatorService, 'evaluate').and.returnValue(true);
|
|
spyOn(objectValueMapperService, 'setFieldFromProvider').and.callFake(function () {
|
|
let deferred = $q.defer();
|
|
deferred.resolve(true);
|
|
return deferred.promise;
|
|
});
|
|
|
|
spyOn(rootScope, '$broadcast');
|
|
spyOn(systemAlertService, 'success');
|
|
spyOn(objectValueMapperService, 'clearProviderActionFromList').and.callFake(function () {
|
|
scope.providerActionsList = [];
|
|
});
|
|
spyOn(screenConfigurationModel, 'executeProviderActionV3').and.callFake(function () {
|
|
let deferred = $q.defer();
|
|
deferred.resolve(providerActionOutput);
|
|
return deferred.promise;
|
|
});
|
|
|
|
scope.$emit(events.PROVIDER_ACTION, data);
|
|
|
|
scope.$apply();
|
|
$timeout.flush();
|
|
|
|
expect(scope.providerActionsList.length).toBe(0);
|
|
expect(screenConfigurationModel.executeProviderActionV3).toHaveBeenCalledWith(data[0].actionId, scope.context.id, {1000000000: ""});
|
|
expect(objectValueMapperService.setFieldFromProvider).toHaveBeenCalledWith(providerActionOutput, actionList[0].mappings);
|
|
expect(rootScope.$broadcast).toHaveBeenCalledWith(events.OPEN_EDIT_MODE);
|
|
expect(systemAlertService.success).toHaveBeenCalled();
|
|
expect(objectValueMapperService.clearProviderActionFromList).toHaveBeenCalledWith(data[0].action);
|
|
});
|
|
|
|
it('should trigger PROVIDER_ACTION events handler and should launch action from expression if provider action expression condition is matched in case of two provider actions',function() {
|
|
var data = [{
|
|
actionId: "AGGAA5V0HG8OSAP7F4UMP6I6DLFQIP",
|
|
expression: "$priority == 'High'",
|
|
action: actionList[0]
|
|
}, {
|
|
actionId: "AGGAA5V0HG8OSAP7F4UMP6I6DLABCD",
|
|
expression: "desc == 'description'",
|
|
action: actionList[1]
|
|
}], providerActionOutput1 = {1000000151: 'description'},
|
|
providerActionOutput2 = {1000000150: 'description'};
|
|
spyOn(objectValueMapperService, 'getProviderActionsList').and.returnValue(data);
|
|
spyOn(expressionEvaluatorService, 'evaluate').and.returnValue(true);
|
|
spyOn(objectValueMapperService, 'setFieldFromProvider').and.callFake(function () {
|
|
let deferred = $q.defer();
|
|
deferred.resolve(true);
|
|
return deferred.promise;
|
|
});
|
|
|
|
spyOn(rootScope, '$broadcast');
|
|
spyOn(systemAlertService, 'success');
|
|
spyOn(objectValueMapperService, 'clearProviderActionFromList').and.callFake(function () {
|
|
scope.providerActionsList.shift();
|
|
});
|
|
spyOn(screenConfigurationModel, 'executeProviderActionV3').and.callFake(function (id) {
|
|
let deferred = $q.defer();
|
|
id == 'AGGAA5V0HG8OSAP7F4UMP6I6DLFQIP' ? deferred.resolve(providerActionOutput1) : deferred.resolve(providerActionOutput2);
|
|
return deferred.promise;
|
|
});
|
|
|
|
scope.$emit(events.PROVIDER_ACTION, data);
|
|
|
|
scope.$apply();
|
|
$timeout.flush();
|
|
|
|
expect(scope.providerActionsList.length).toBe(0);
|
|
expect(screenConfigurationModel.executeProviderActionV3).toHaveBeenCalledWith(actionList[0].id, scope.context.id, {1000000000: ""});
|
|
expect(objectValueMapperService.setFieldFromProvider).toHaveBeenCalledWith(providerActionOutput1, actionList[0].mappings);
|
|
expect(rootScope.$broadcast).toHaveBeenCalledWith(events.OPEN_EDIT_MODE);
|
|
expect(systemAlertService.success).toHaveBeenCalled();
|
|
expect(objectValueMapperService.clearProviderActionFromList).toHaveBeenCalledWith(actionList[0]);
|
|
expect(screenConfigurationModel.executeProviderActionV3).toHaveBeenCalledWith(actionList[1].id, scope.context.id, {1000000151: ""});
|
|
expect(objectValueMapperService.setFieldFromProvider).toHaveBeenCalledWith(providerActionOutput2, actionList[1].mappings);
|
|
expect(objectValueMapperService.clearProviderActionFromList).toHaveBeenCalledWith(actionList[1]);
|
|
});
|
|
|
|
it('should trigger PROVIDER_ACTION events handler and should launch action from expression if provider action expression condition is matched and there is an error while executing provider action',function() {
|
|
var data = [{
|
|
actionId: "AGGAA5V0HG8OSAP7F4UMP6I6DLFQIP",
|
|
expression: "$priority == 'High'",
|
|
action: actionList[0]
|
|
}], errorMsg = {
|
|
data: {
|
|
error: 'Server Issue'
|
|
}
|
|
};
|
|
actionList[0].mappings = [
|
|
{
|
|
"type": "input-ticket",
|
|
"mappedFieldId": 1000000000,
|
|
"mappedFieldValue": "requiredResolutionDate"
|
|
},
|
|
{
|
|
"type": "output",
|
|
"mappedFieldId": 1000000151,
|
|
"mappedFieldValue": "desc"
|
|
}
|
|
];
|
|
|
|
spyOn(objectValueMapperService, 'getProviderActionsList').and.returnValue(data);
|
|
spyOn(expressionEvaluatorService, 'evaluate').and.returnValue(true);
|
|
spyOn(objectValueMapperService, 'setFieldFromProvider').and.callFake(function () {
|
|
let deferred = $q.defer();
|
|
deferred.resolve(true);
|
|
return deferred.promise;
|
|
});
|
|
|
|
spyOn(systemAlertService, 'error');
|
|
spyOn(objectValueMapperService, 'clearProviderActionFromList').and.callFake(function () {
|
|
scope.providerActionsList = [];
|
|
});
|
|
spyOn(screenConfigurationModel, 'executeProviderActionV3').and.callFake(function () {
|
|
let deferred = $q.defer();
|
|
deferred.reject(errorMsg);
|
|
return deferred.promise;
|
|
});
|
|
|
|
scope.$emit(events.PROVIDER_ACTION, data);
|
|
|
|
scope.$apply();
|
|
//$timeout.flush();
|
|
|
|
expect(scope.providerActionsList.length).toBe(0);
|
|
expect(screenConfigurationModel.executeProviderActionV3).toHaveBeenCalledWith(data[0].actionId, scope.context.id, {1000000000: ""});
|
|
expect(systemAlertService.error).toHaveBeenCalledWith({text: errorMsg.data.error, clear: false});
|
|
expect(objectValueMapperService.clearProviderActionFromList).toHaveBeenCalledWith(data[0].action);
|
|
});
|
|
}); |