0f55b39a6b
This change will modify a number of things about the way
we manage guideline sources
- it allows the api to pull guidelines from a list of
additional guideline sources, as specified in conf
- changes the object returned by the guidelines api
from a list to a dictionary of lists pertaining to
a specific guideline type
Change-Id: Ic42197b32d4c9030a35e613cae8cc64dca794c85
1759 lines
70 KiB
JavaScript
1759 lines
70 KiB
JavaScript
/** Jasmine specs for Refstack controllers */
|
|
describe('Refstack controllers', function () {
|
|
'use strict';
|
|
|
|
var fakeApiUrl = 'http://foo.bar/v1';
|
|
var $httpBackend;
|
|
beforeEach(function () {
|
|
module(function ($provide) {
|
|
$provide.constant('refstackApiUrl', fakeApiUrl);
|
|
});
|
|
module('refstackApp');
|
|
inject(function(_$httpBackend_) {
|
|
$httpBackend = _$httpBackend_;
|
|
});
|
|
$httpBackend.whenGET(fakeApiUrl + '/profile').respond(401);
|
|
$httpBackend.whenGET('/components/home/home.html')
|
|
.respond('<div>mock template</div>');
|
|
});
|
|
|
|
describe('HeaderController', function () {
|
|
var $location, ctrl;
|
|
|
|
beforeEach(inject(function ($controller, _$location_) {
|
|
$location = _$location_;
|
|
ctrl = $controller('HeaderController', {});
|
|
}));
|
|
|
|
it('should set "navbarCollapsed" to true', function () {
|
|
expect(ctrl.navbarCollapsed).toBe(true);
|
|
});
|
|
|
|
it('should have a function to check if the URL path is active',
|
|
function () {
|
|
$location.path('/');
|
|
expect($location.path()).toBe('/');
|
|
expect(ctrl.isActive('/')).toBe(true);
|
|
expect(ctrl.isActive('/about')).toBe(false);
|
|
|
|
$location.path('/results?cpid=123&foo=bar');
|
|
expect($location.path()).toBe('/results?cpid=123&foo=bar');
|
|
expect(ctrl.isActive('/results')).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('LogoutController', function () {
|
|
var $location, ctrl;
|
|
|
|
beforeEach(inject(function ($controller, _$location_) {
|
|
$location = _$location_;
|
|
$location.url('/logout?openid_logout=some_url');
|
|
ctrl = $controller('LogoutController', {});
|
|
}));
|
|
|
|
it('should set the openID logout URL based on query string',
|
|
function () {
|
|
expect($location.url()).toBe('/logout?openid_logout=some_url');
|
|
expect(ctrl.openid_logout_url).toBe('some_url');
|
|
});
|
|
});
|
|
|
|
describe('AboutController', function () {
|
|
var $location, ctrl;
|
|
|
|
beforeEach(inject(function ($controller, _$location_) {
|
|
$location = _$location_;
|
|
ctrl = $controller('AboutController', {});
|
|
ctrl.options = {
|
|
'about' : {
|
|
'title': 'About RefStack',
|
|
'template': 'about-template'
|
|
},
|
|
'option1' : {
|
|
'title': 'Option One',
|
|
'template': 'template-1'
|
|
}
|
|
};
|
|
}));
|
|
|
|
it('should have a function to select an option',
|
|
function () {
|
|
ctrl.selectOption('option1');
|
|
expect(ctrl.selected).toBe('option1');
|
|
expect(ctrl.template).toBe('template-1');
|
|
expect($location.hash()).toBe('option1');
|
|
});
|
|
|
|
it('should have a function to get the URL hash and select it',
|
|
function () {
|
|
// Test existing option.
|
|
$location.url('/about#option1');
|
|
ctrl.getHash();
|
|
expect(ctrl.selected).toBe('option1');
|
|
expect(ctrl.template).toBe('template-1');
|
|
|
|
// Test nonexistent option.
|
|
$location.url('/about#foobar');
|
|
ctrl.getHash();
|
|
expect(ctrl.selected).toBe('about');
|
|
expect(ctrl.template).toBe('about-template');
|
|
});
|
|
|
|
});
|
|
|
|
describe('GuidelinesController', function () {
|
|
var ctrl;
|
|
|
|
beforeEach(inject(function ($controller) {
|
|
ctrl = $controller('GuidelinesController', {});
|
|
}));
|
|
|
|
it('should set default states', function () {
|
|
expect(ctrl.target).toBe('platform');
|
|
expect(ctrl.status).toEqual({
|
|
required: true, advisory: false,
|
|
deprecated: false, removed: false
|
|
});
|
|
});
|
|
|
|
it('should fetch the selected capabilities version and sort a ' +
|
|
'program\'s capabilities into an object',
|
|
function () {
|
|
var fakeCaps = {
|
|
'schema': '1.3',
|
|
'status': 'approved',
|
|
'platform': {'required': ['compute']},
|
|
'components': {
|
|
'compute': {
|
|
'required': ['cap_id_1'],
|
|
'advisory': ['cap_id_2'],
|
|
'deprecated': ['cap_id_3'],
|
|
'removed': ['cap_id_4']
|
|
}
|
|
}
|
|
};
|
|
let get_gl_resp = {
|
|
'powered': [
|
|
{'name': 'next.json', 'file': 'next.json'},
|
|
{'name': '2015.04.json', 'file': '2015.04.json'},
|
|
{'name': '2015.03.json', 'file': '2015.03.json'}
|
|
]
|
|
};
|
|
$httpBackend.expectGET(fakeApiUrl + '/guidelines').respond(
|
|
get_gl_resp);
|
|
// Should call request with latest version.
|
|
$httpBackend.expectGET(
|
|
fakeApiUrl + '/guidelines/2015.04.json').respond(fakeCaps);
|
|
$httpBackend.flush();
|
|
// The version list should be sorted latest first.
|
|
let expected_version_list = [
|
|
{'name': 'next.json', 'file': 'next.json'},
|
|
{'name': '2015.04.json', 'file': '2015.04.json'},
|
|
{'name': '2015.03.json', 'file': '2015.03.json'}
|
|
];
|
|
expect(ctrl.versionList).toEqual(expected_version_list);
|
|
|
|
expect(ctrl.guidelines).toEqual(fakeCaps);
|
|
// The guideline status should be approved.
|
|
expect(ctrl.guidelineStatus).toEqual('approved');
|
|
var expectedTargetCaps = {
|
|
'cap_id_1': 'required',
|
|
'cap_id_2': 'advisory',
|
|
'cap_id_3': 'deprecated',
|
|
'cap_id_4': 'removed'
|
|
};
|
|
expect(ctrl.targetCapabilities).toEqual(expectedTargetCaps);
|
|
});
|
|
|
|
it('should be able to handle guidelines using schema 2.0',
|
|
function () {
|
|
var fakeCaps = {
|
|
'metadata': {
|
|
'id': '2017.08',
|
|
'schema': '2.0',
|
|
'scoring': {},
|
|
'os_trademark_approval': {
|
|
'target_approval': '2017.08',
|
|
'replaces': '2017.01',
|
|
'releases': ['newton', 'ocata', 'pike'],
|
|
'status': 'approved'
|
|
}
|
|
},
|
|
'platforms': {
|
|
'OpenStack Powered Platform': {
|
|
'description': 'foo bar',
|
|
'components': [
|
|
{ 'name': 'os_powered_compute' },
|
|
{ 'name': 'os_powered_storage' }
|
|
]
|
|
}
|
|
},
|
|
'components': {
|
|
'os_powered_compute': {
|
|
'capabilities': {
|
|
'required': ['cap_id_1'],
|
|
'advisory': ['cap_id_2'],
|
|
'deprecated': ['cap_id_3'],
|
|
'removed': ['cap_id_4']
|
|
}
|
|
},
|
|
'os_powered_storage': {
|
|
'capabilities': {
|
|
'required': ['cap_id_5'],
|
|
'advisory': ['cap_id_6'],
|
|
'deprecated': ['cap_id_7'],
|
|
'removed': ['cap_id_8']
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
$httpBackend.expectGET(fakeApiUrl +
|
|
'/guidelines').respond({
|
|
'powered': [
|
|
{'name': 'next.json', 'file': 'next.json'},
|
|
{'name': '2015.03.json', 'file': '2015.03.json'},
|
|
{'name': '2017.08.json', 'file': '2017.08.json'}
|
|
]
|
|
});
|
|
|
|
// Should call request with latest version.
|
|
$httpBackend.expectGET(fakeApiUrl +
|
|
'/guidelines/2017.08.json').respond(fakeCaps);
|
|
$httpBackend.flush();
|
|
|
|
ctrl.update();
|
|
// The version list should be sorted latest first.
|
|
expect(ctrl.guidelines).toEqual(fakeCaps);
|
|
// The guideline status should be approved.
|
|
expect(ctrl.guidelineStatus).toEqual('approved');
|
|
var expectedTargetCaps = {
|
|
'cap_id_1': 'required',
|
|
'cap_id_2': 'advisory',
|
|
'cap_id_3': 'deprecated',
|
|
'cap_id_4': 'removed',
|
|
'cap_id_5': 'required',
|
|
'cap_id_6': 'advisory',
|
|
'cap_id_7': 'deprecated',
|
|
'cap_id_8': 'removed'
|
|
};
|
|
expect(ctrl.targetCapabilities).toEqual(expectedTargetCaps);
|
|
});
|
|
|
|
it('should have a function to check if a capability status is selected',
|
|
function () {
|
|
ctrl.targetCapabilities = {
|
|
'cap_id_1': 'required',
|
|
'cap_id_2': 'advisory',
|
|
'cap_id_3': 'deprecated',
|
|
'cap_id_4': 'removed'
|
|
};
|
|
|
|
// Expect only the required capability to return true.
|
|
expect(ctrl.filterStatus({'id': 'cap_id_1'})).toBe(true);
|
|
expect(ctrl.filterStatus({'id': 'cap_id_2'})).toBe(false);
|
|
expect(ctrl.filterStatus({'id': 'cap_id_3'})).toBe(false);
|
|
expect(ctrl.filterStatus({'id': 'cap_id_4'})).toBe(false);
|
|
|
|
ctrl.status = {
|
|
required: true,
|
|
advisory: true,
|
|
deprecated: true,
|
|
removed: true
|
|
};
|
|
|
|
// Every capability should return true now.
|
|
expect(ctrl.filterStatus({'id': 'cap_id_1'})).toBe(true);
|
|
expect(ctrl.filterStatus({'id': 'cap_id_2'})).toBe(true);
|
|
expect(ctrl.filterStatus({'id': 'cap_id_3'})).toBe(true);
|
|
expect(ctrl.filterStatus({'id': 'cap_id_4'})).toBe(true);
|
|
});
|
|
|
|
it('should have a function to get the length of an object/dict',
|
|
function () {
|
|
var testObject = {
|
|
'test_id_1': {
|
|
'idempotent_id': 'id-1234'
|
|
},
|
|
'test_id_2': {
|
|
'idempotent_id': 'id-5678'
|
|
}
|
|
};
|
|
expect(ctrl.getObjectLength(testObject)).toBe(2);
|
|
});
|
|
|
|
it('should have a method to open a modal for the relevant test list',
|
|
function () {
|
|
var modal;
|
|
inject(function ($uibModal) {
|
|
modal = $uibModal;
|
|
});
|
|
spyOn(modal, 'open');
|
|
ctrl.openTestListModal();
|
|
expect(modal.open).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('TestListModalController', function () {
|
|
var modalInstance, ctrl;
|
|
|
|
beforeEach(inject(function ($controller) {
|
|
modalInstance = {
|
|
dismiss: jasmine.createSpy('modalInstance.dismiss')
|
|
};
|
|
ctrl = $controller('TestListModalController',
|
|
{$uibModalInstance: modalInstance,
|
|
target: 'platform',
|
|
version: '2016.01',
|
|
version_file: '2016.01.json',
|
|
status: {required: true, advisory: false}}
|
|
);
|
|
}));
|
|
|
|
it('should have a method to close the modal',
|
|
function () {
|
|
ctrl.close();
|
|
expect(modalInstance.dismiss).toHaveBeenCalledWith('exit');
|
|
});
|
|
|
|
it('should have a method to download the test list string',
|
|
function () {
|
|
var fakeResp = 'test1\ntest2\ntest3';
|
|
$httpBackend.expectGET(fakeApiUrl +
|
|
'/guidelines/2016.01.json/tests?target=platform&' +
|
|
'type=required&alias=true&flag=false').respond(fakeResp);
|
|
$httpBackend.flush();
|
|
ctrl.updateTestListString();
|
|
expect(ctrl.testListCount).toBe(3);
|
|
});
|
|
});
|
|
|
|
describe('ResultsController', function () {
|
|
var scope, ctrl;
|
|
var fakeResponse = {
|
|
'pagination': {'current_page': 1, 'total_pages': 2},
|
|
'results': [{
|
|
'created_at': '2015-03-09 01:23:45',
|
|
'id': 'some-id',
|
|
'cpid': 'some-cpid'
|
|
}]
|
|
};
|
|
var fakeVendorResp = {
|
|
'vendors': [{'id': 'fakeid', 'name': 'Foo Vendor'}]
|
|
};
|
|
|
|
beforeEach(inject(function ($rootScope, $controller) {
|
|
scope = $rootScope.$new();
|
|
ctrl = $controller('ResultsController', {$scope: scope});
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/results?page=1').respond(fakeResponse);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/vendors').respond(fakeVendorResp);
|
|
}));
|
|
|
|
it('should fetch the first page of results with proper URL args',
|
|
function () {
|
|
// Initial results should be page 1 of all results.
|
|
$httpBackend.expectGET(fakeApiUrl + '/results?page=1')
|
|
.respond(fakeResponse);
|
|
$httpBackend.flush();
|
|
expect(ctrl.data).toEqual(fakeResponse);
|
|
expect(ctrl.currentPage).toBe(1);
|
|
|
|
// Simulate the user adding date filters.
|
|
ctrl.startDate = new Date('2015-03-10T11:51:00');
|
|
ctrl.endDate = new Date('2015-04-10T11:51:00');
|
|
ctrl.update();
|
|
$httpBackend.expectGET(fakeApiUrl +
|
|
'/results?page=1' +
|
|
'&start_date=2015-03-10 00:00:00' +
|
|
'&end_date=2015-04-10 23:59:59')
|
|
.respond(fakeResponse);
|
|
$httpBackend.flush();
|
|
expect(ctrl.data).toEqual(fakeResponse);
|
|
expect(ctrl.currentPage).toBe(1);
|
|
});
|
|
|
|
it('should set an error when results cannot be retrieved', function () {
|
|
$httpBackend.expectGET(fakeApiUrl + '/results?page=1').respond(404,
|
|
{'detail': 'Not Found'});
|
|
$httpBackend.flush();
|
|
expect(ctrl.data).toBe(null);
|
|
expect(ctrl.error).toEqual('Error retrieving results listing ' +
|
|
'from server: {"detail":"Not Found"}');
|
|
expect(ctrl.totalItems).toBe(0);
|
|
expect(ctrl.showError).toBe(true);
|
|
});
|
|
|
|
it('should have an function to clear filters and update the view',
|
|
function () {
|
|
ctrl.startDate = 'some date';
|
|
ctrl.endDate = 'some other date';
|
|
ctrl.clearFilters();
|
|
expect(ctrl.startDate).toBe(null);
|
|
expect(ctrl.endDate).toBe(null);
|
|
});
|
|
|
|
it('should have a function to associate metadata to a test run',
|
|
function () {
|
|
$httpBackend.expectGET(fakeApiUrl + '/results?page=1')
|
|
.respond(fakeResponse);
|
|
ctrl.data = fakeResponse;
|
|
ctrl.data.results[0].targetEdit = true;
|
|
ctrl.associateMeta(0, 'target', 'platform');
|
|
$httpBackend.expectPOST(
|
|
fakeApiUrl + '/results/some-id/meta/target',
|
|
'platform')
|
|
.respond(201, '');
|
|
$httpBackend.flush();
|
|
expect(ctrl.data.results[0].targetEdit).toBe(false);
|
|
});
|
|
|
|
it('should have a function to delete metadata from a test run',
|
|
function () {
|
|
$httpBackend.expectGET(fakeApiUrl + '/results?page=1')
|
|
.respond(fakeResponse);
|
|
ctrl.data = fakeResponse;
|
|
ctrl.data.results[0].targetEdit = true;
|
|
ctrl.associateMeta(0, 'target', '');
|
|
$httpBackend.expectDELETE(
|
|
fakeApiUrl + '/results/some-id/meta/target')
|
|
.respond(200, '');
|
|
$httpBackend.flush();
|
|
expect(ctrl.data.results[0].targetEdit).toBe(false);
|
|
});
|
|
|
|
it('should have a function to get guideline versions',
|
|
function () {
|
|
$httpBackend.expectGET(fakeApiUrl + '/results?page=1')
|
|
.respond(fakeResponse);
|
|
var expectedResponse = {
|
|
'powered': [
|
|
{'name': '2015.03.json', 'file': '2015.03.json'},
|
|
{'name': '2015.04.json', 'file': '2015.04.json'}
|
|
]
|
|
};
|
|
$httpBackend.expectGET(fakeApiUrl +
|
|
'/guidelines').respond(expectedResponse);
|
|
ctrl.getVersionList();
|
|
$httpBackend.flush();
|
|
// Expect the list to have the latest guideline first.
|
|
let gl_names =
|
|
expectedResponse.powered.map((gl_obj) => gl_obj.name);
|
|
let expectedVersionList =
|
|
gl_names.sort();
|
|
if (typeof ctrl.versionList !== 'undefined') {
|
|
expect(ctrl.versionList).toEqual(expectedVersionList);
|
|
}
|
|
});
|
|
|
|
it('should have a function to get products manageable by a user',
|
|
function () {
|
|
var prodResp = {'products': [
|
|
{'id': 'abc', 'can_manage': true},
|
|
{'id': 'foo', 'can_manage': false}]};
|
|
ctrl.products = null;
|
|
$httpBackend.expectGET(fakeApiUrl + '/products')
|
|
.respond(200, prodResp);
|
|
ctrl.getUserProducts();
|
|
$httpBackend.flush();
|
|
var expected = {'abc': {'id': 'abc', 'can_manage': true}};
|
|
expect(ctrl.products).toEqual(expected);
|
|
});
|
|
|
|
it('should have a function to get a listing of vendors',
|
|
function () {
|
|
$httpBackend.expectGET(fakeApiUrl + '/vendors')
|
|
.respond(fakeVendorResp);
|
|
ctrl.getVendors();
|
|
$httpBackend.flush();
|
|
var expected = fakeVendorResp.vendors[0];
|
|
expect(ctrl.vendors.fakeid).toEqual(expected);
|
|
});
|
|
|
|
it('should have a function to associate a product version to a test',
|
|
function () {
|
|
var result = {'id': 'bar',
|
|
'selectedVersion': {'id': 'foo'},
|
|
'selectedProduct': {'id': 'prod'}};
|
|
ctrl.products = null;
|
|
$httpBackend.expectPUT(fakeApiUrl + '/results/bar')
|
|
.respond(201);
|
|
ctrl.associateProductVersion(result);
|
|
$httpBackend.flush();
|
|
var expected = {'id': 'foo', 'product_info': {'id': 'prod'}};
|
|
expect(result.product_version).toEqual(expected);
|
|
});
|
|
|
|
it('should have a function to get product versions',
|
|
function () {
|
|
var result = {'id': 'bar',
|
|
'selectedProduct': {'id': 'prod'}};
|
|
var verResp = [{'id': 'ver1', 'version': '1.0'},
|
|
{'id': 'ver2', 'version': null}];
|
|
ctrl.products = null;
|
|
$httpBackend.expectGET(fakeApiUrl + '/products/prod/versions')
|
|
.respond(200, verResp);
|
|
ctrl.getProductVersions(result);
|
|
$httpBackend.flush();
|
|
expect(result.productVersions).toEqual(verResp);
|
|
var expected = {'id': 'ver2', 'version': null};
|
|
expect(result.selectedVersion).toEqual(expected);
|
|
});
|
|
});
|
|
|
|
describe('ResultsReportController', function () {
|
|
var stateparams, ctrl;
|
|
var fakeResultResponse = {'results': ['test_id_1'], 'meta': {
|
|
'public_key': 'ssh-rsa', 'guideline': '2015.04.json', 'target':
|
|
'object'
|
|
}};
|
|
var fakeCapabilityResponse = {
|
|
'platform': {'required': ['compute']},
|
|
'schema': '1.2',
|
|
'status': 'approved',
|
|
'components': {
|
|
'compute': {
|
|
'required': ['cap_id_1'],
|
|
'advisory': [],
|
|
'deprecated': [],
|
|
'removed': []
|
|
}
|
|
},
|
|
'capabilities': {
|
|
'cap_id_1': {
|
|
'flagged': [ 'test_id_1'],
|
|
'tests': ['test_id_1', 'test_id_2']
|
|
}
|
|
}
|
|
};
|
|
var fakeGuidelinesListResponse = {
|
|
'powered': [
|
|
{'name': 'next.json', 'file': 'next.json'},
|
|
{'name': '2015.04.json', 'file': '2015.04.json'},
|
|
{'name': '2015.03.json', 'file': '2015.03.json'}
|
|
]
|
|
};
|
|
|
|
beforeEach(inject(function ($controller) {
|
|
stateparams = {testID: 1234};
|
|
ctrl = $controller('ResultsReportController',
|
|
{$stateParams: stateparams}
|
|
);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/results/1234').respond(fakeResultResponse);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/guidelines').respond(fakeGuidelinesListResponse);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/guidelines/2015.04.json').respond(fakeCapabilityResponse);
|
|
}));
|
|
|
|
it('should make all necessary API requests to get results ' +
|
|
'and guidelines',
|
|
function () {
|
|
$httpBackend.expectGET(fakeApiUrl +
|
|
'/results/1234').respond(fakeResultResponse);
|
|
$httpBackend.expectGET(fakeApiUrl +
|
|
'/guidelines').respond({
|
|
'powered': [
|
|
{'name': '2015.03.json', 'file': '2015.03.json'},
|
|
{'name': '2015.04.json', 'file': '2015.04.json'}
|
|
]
|
|
});
|
|
// Should call request with latest version.
|
|
$httpBackend.expectGET(fakeApiUrl +
|
|
'/guidelines/2015.04.json').respond(fakeCapabilityResponse);
|
|
$httpBackend.flush();
|
|
expect(ctrl.resultsData).toEqual(fakeResultResponse);
|
|
// The version list should be sorted latest first.
|
|
let expected_version_list = ['2015.04.json', '2015.03.json'];
|
|
expect(ctrl.versionList).toEqual(expected_version_list);
|
|
expect(ctrl.guidelineData).toEqual(fakeCapabilityResponse);
|
|
// The guideline status should be approved.
|
|
expect(ctrl.guidelineData.status).toEqual('approved');
|
|
expect(ctrl.schemaVersion).toEqual('1.2');
|
|
});
|
|
|
|
it('should have a method that creates an object containing each ' +
|
|
'relevant capability and its highest priority status',
|
|
function () {
|
|
ctrl.guidelineData = {
|
|
'schema': '1.3',
|
|
'platform': {'required': ['compute', 'object']},
|
|
'components': {
|
|
'compute': {
|
|
'required': ['cap_id_1'],
|
|
'advisory': ['cap_id_2'],
|
|
'deprecated': ['cap_id_3'],
|
|
'removed': []
|
|
},
|
|
'object': {
|
|
'required': ['cap_id_2'],
|
|
'advisory': ['cap_id_1', 'cap_id_3'],
|
|
'deprecated': [],
|
|
'removed': []
|
|
}
|
|
}
|
|
};
|
|
var expected = {
|
|
'cap_id_1': 'required',
|
|
'cap_id_2': 'required',
|
|
'cap_id_3': 'advisory'
|
|
};
|
|
expect(ctrl.getTargetCapabilities()).toEqual(expected);
|
|
});
|
|
|
|
it('should be able create an object containing each relevant' +
|
|
'capability and its highest priority status for schema 2.0',
|
|
function () {
|
|
ctrl.schemaVersion = '2.0';
|
|
ctrl.guidelineData = {
|
|
'metadata': {
|
|
'id': '2017.08',
|
|
'schema': '2.0',
|
|
'scoring': {},
|
|
'os_trademark_approval': {
|
|
'target_approval': '2017.08',
|
|
'replaces': '2017.01',
|
|
'releases': ['newton', 'ocata', 'pike'],
|
|
'status': 'approved'
|
|
}
|
|
},
|
|
'platforms': {
|
|
'OpenStack Powered Platform': {
|
|
'description': 'foo bar',
|
|
'components': [
|
|
{ 'name': 'os_powered_compute' },
|
|
{ 'name': 'os_powered_storage' }
|
|
]
|
|
}
|
|
},
|
|
'components': {
|
|
'os_powered_compute': {
|
|
'capabilities': {
|
|
'required': ['cap_id_1'],
|
|
'advisory': ['cap_id_2'],
|
|
'deprecated': ['cap_id_3'],
|
|
'removed': ['cap_id_4']
|
|
}
|
|
},
|
|
'os_powered_storage': {
|
|
'capabilities': {
|
|
'required': ['cap_id_5'],
|
|
'advisory': ['cap_id_6'],
|
|
'deprecated': ['cap_id_7'],
|
|
'removed': ['cap_id_8']
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var expected = {
|
|
'cap_id_1': 'required',
|
|
'cap_id_2': 'advisory',
|
|
'cap_id_3': 'deprecated',
|
|
'cap_id_4': 'removed',
|
|
'cap_id_5': 'required',
|
|
'cap_id_6': 'advisory',
|
|
'cap_id_7': 'deprecated',
|
|
'cap_id_8': 'removed'
|
|
};
|
|
expect(ctrl.getTargetCapabilities()).toEqual(expected);
|
|
});
|
|
|
|
it('should be able to sort the results into a capability object for ' +
|
|
'schema version 1.2',
|
|
function () {
|
|
ctrl.resultsData = fakeResultResponse;
|
|
ctrl.guidelineData = fakeCapabilityResponse;
|
|
ctrl.schemaVersion = '1.2';
|
|
ctrl.buildCapabilitiesObject();
|
|
var expectedCapsObject = {
|
|
'required': {
|
|
'caps': [{
|
|
'id': 'cap_id_1',
|
|
'passedTests': ['test_id_1'],
|
|
'notPassedTests': ['test_id_2'],
|
|
'passedFlagged': ['test_id_1'],
|
|
'notPassedFlagged': []
|
|
}],
|
|
'count': 2, 'passedCount': 1,
|
|
'flagFailCount': 0, 'flagPassCount': 1
|
|
},
|
|
'advisory': {'caps': [], 'count': 0, 'passedCount': 0,
|
|
'flagFailCount': 0, 'flagPassCount': 0},
|
|
'deprecated': {'caps': [], 'count': 0, 'passedCount': 0,
|
|
'flagFailCount': 0, 'flagPassCount': 0},
|
|
'removed': {'caps': [], 'count': 0, 'passedCount': 0,
|
|
'flagFailCount': 0, 'flagPassCount': 0}
|
|
};
|
|
expect(ctrl.caps).toEqual(expectedCapsObject);
|
|
expect(ctrl.requiredPassPercent).toEqual(50);
|
|
expect(ctrl.nonFlagPassCount).toEqual(0);
|
|
});
|
|
|
|
it('should be able to sort the results into a capability object for ' +
|
|
'schema version 1.3 and above',
|
|
function () {
|
|
ctrl.resultsData = {'results': ['test_id_1',
|
|
'old_test_id_3',
|
|
'test_id_4']
|
|
};
|
|
ctrl.guidelineData = {
|
|
'platform': {'required': ['compute']},
|
|
'schema': '1.4',
|
|
'components': {
|
|
'compute': {
|
|
'required': ['cap_id_1'],
|
|
'advisory': [],
|
|
'deprecated': [],
|
|
'removed': []
|
|
}
|
|
},
|
|
'capabilities': {
|
|
'cap_id_1': {
|
|
'tests': {
|
|
'test_id_1': {
|
|
'flagged': {
|
|
'action': 'foo',
|
|
'date': '2015-03-24',
|
|
'reason': 'bar'
|
|
},
|
|
'idempotent_id': 'id-1234'
|
|
},
|
|
'test_id_2': {
|
|
'idempotent_id': 'id-5678'
|
|
},
|
|
'test_id_3': {
|
|
'idempotent_id': 'id-5679',
|
|
'aliases': ['old_test_id_3']
|
|
},
|
|
'test_id_4': {
|
|
'idempotent_id': 'id-5680'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
ctrl.schemaVersion = '1.4';
|
|
ctrl.buildCapabilitiesObject();
|
|
var expectedCapsObject = {
|
|
'required': {
|
|
'caps': [{
|
|
'id': 'cap_id_1',
|
|
'passedTests': ['test_id_1',
|
|
'test_id_3',
|
|
'test_id_4'],
|
|
'notPassedTests': ['test_id_2'],
|
|
'passedFlagged': ['test_id_1'],
|
|
'notPassedFlagged': []
|
|
}],
|
|
'count': 4, 'passedCount': 3,
|
|
'flagFailCount': 0, 'flagPassCount': 1
|
|
},
|
|
'advisory': {'caps': [], 'count': 0, 'passedCount': 0,
|
|
'flagFailCount': 0, 'flagPassCount': 0},
|
|
'deprecated': {'caps': [], 'count': 0, 'passedCount': 0,
|
|
'flagFailCount': 0, 'flagPassCount': 0},
|
|
'removed': {'caps': [], 'count': 0, 'passedCount': 0,
|
|
'flagFailCount': 0, 'flagPassCount': 0}
|
|
};
|
|
expect(ctrl.caps).toEqual(expectedCapsObject);
|
|
expect(ctrl.requiredPassPercent).toEqual(75);
|
|
expect(ctrl.nonFlagPassCount).toEqual(2);
|
|
|
|
// Test case where a component capability isn't listed in
|
|
// the capabilities object.
|
|
ctrl.guidelineData.components.compute.removed = ['fake_cap'];
|
|
ctrl.buildCapabilitiesObject();
|
|
expectedCapsObject.removed.caps = [{
|
|
'id': 'fake_cap',
|
|
'passedTests': [],
|
|
'notPassedTests': [],
|
|
'passedFlagged': [],
|
|
'notPassedFlagged': []
|
|
}];
|
|
expect(ctrl.caps).toEqual(expectedCapsObject);
|
|
});
|
|
|
|
it('should have a method to determine if a test is flagged',
|
|
function () {
|
|
var capObj = {'flagged': [ 'test1'],
|
|
'tests': ['test1', 'test2']};
|
|
|
|
ctrl.schemaVersion = '1.2';
|
|
expect(ctrl.isTestFlagged('test1', capObj)).toEqual(true);
|
|
expect(ctrl.isTestFlagged('test2', capObj)).toEqual(false);
|
|
|
|
capObj = {
|
|
'tests': {
|
|
'test1': {
|
|
'flagged': {
|
|
'action': 'foo',
|
|
'date': '2015-03-24',
|
|
'reason': 'bar'
|
|
},
|
|
'idempotent_id': 'id-1234'
|
|
},
|
|
'test2': {
|
|
'idempotent_id': 'id-5678'
|
|
}
|
|
}
|
|
};
|
|
|
|
ctrl.schemaVersion = '1.3';
|
|
expect(ctrl.isTestFlagged('test1', capObj)).toBeTruthy();
|
|
expect(ctrl.isTestFlagged('test2', capObj)).toBeFalsy();
|
|
|
|
expect(ctrl.isTestFlagged('test2', null)).toEqual(false);
|
|
});
|
|
|
|
it('should have a method to get the reason a flagged test is flagged',
|
|
function () {
|
|
var capObj = {'flagged': [ 'test1'],
|
|
'tests': ['test1', 'test2']};
|
|
|
|
ctrl.schemaVersion = '1.2';
|
|
expect(ctrl.getFlaggedReason('test1', capObj)).toEqual(
|
|
'Interop Working Group has flagged this test.');
|
|
|
|
// Check that non-flagged test returns empty string.
|
|
expect(ctrl.getFlaggedReason('test2', capObj)).toEqual('');
|
|
|
|
capObj = {
|
|
'tests': {
|
|
'test1': {
|
|
'flagged': {
|
|
'action': 'foo',
|
|
'date': '2015-03-24',
|
|
'reason': 'bar'
|
|
},
|
|
'idempotent_id': 'id-1234'
|
|
}
|
|
}
|
|
};
|
|
|
|
ctrl.schemaVersion = '1.3';
|
|
expect(ctrl.getFlaggedReason('test1', capObj)).toEqual('bar');
|
|
});
|
|
|
|
it('should have a method to determine whether a capability should ' +
|
|
'be shown',
|
|
function () {
|
|
var caps = [{'id': 'cap_id_1',
|
|
'passedTests': ['test_id_1'],
|
|
'notPassedTests': [],
|
|
'passedFlagged': ['test_id_1'],
|
|
'notPassedFlagged': []
|
|
},
|
|
{'id': 'cap_id_2',
|
|
'passedTests': [],
|
|
'notPassedTests': ['test_id_4'],
|
|
'passedFlagged': [],
|
|
'notPassedFlagged': []
|
|
}];
|
|
|
|
// Check that all capabilities are shown by default.
|
|
expect(ctrl.isCapabilityShown(caps[0])).toEqual(true);
|
|
expect(ctrl.isCapabilityShown(caps[1])).toEqual(true);
|
|
|
|
// Check that only capabilities with passed tests are shown.
|
|
ctrl.testStatus = 'passed';
|
|
expect(ctrl.isCapabilityShown(caps[0])).toEqual(true);
|
|
expect(ctrl.isCapabilityShown(caps[1])).toEqual(false);
|
|
|
|
// Check that only capabilities with passed tests are shown.
|
|
ctrl.testStatus = 'not passed';
|
|
expect(ctrl.isCapabilityShown(caps[0])).toEqual(false);
|
|
expect(ctrl.isCapabilityShown(caps[1])).toEqual(true);
|
|
|
|
// Check that only capabilities with flagged tests are shown.
|
|
ctrl.testStatus = 'flagged';
|
|
expect(ctrl.isCapabilityShown(caps[0])).toEqual(true);
|
|
expect(ctrl.isCapabilityShown(caps[1])).toEqual(false);
|
|
});
|
|
|
|
it('should have a method to determine whether a test should be shown',
|
|
function () {
|
|
var cap = {'id': 'cap_id_1',
|
|
'passedTests': ['test_id_1'],
|
|
'notPassedTests': [],
|
|
'passedFlagged': ['test_id_1'],
|
|
'notPassedFlagged': []
|
|
};
|
|
|
|
expect(ctrl.isTestShown('test_id_1', cap)).toEqual(true);
|
|
ctrl.testStatus = 'passed';
|
|
expect(ctrl.isTestShown('test_id_1', cap)).toEqual(true);
|
|
ctrl.testStatus = 'not passed';
|
|
expect(ctrl.isTestShown('test_id_1', cap)).toEqual(false);
|
|
ctrl.testStatus = 'flagged';
|
|
expect(ctrl.isTestShown('test_id_1', cap)).toEqual(true);
|
|
});
|
|
|
|
it('should have a method to determine how many tests in a ' +
|
|
'capability belong under the current test filter',
|
|
function () {
|
|
var cap = {'id': 'cap_id_1',
|
|
'passedTests': ['t1', 't2', 't3'],
|
|
'notPassedTests': ['t4', 't5', 't6', 't7'],
|
|
'passedFlagged': ['t1'],
|
|
'notPassedFlagged': ['t3', 't4']
|
|
};
|
|
|
|
// Should return the count of all tests.
|
|
expect(ctrl.getCapabilityTestCount(cap)).toEqual(7);
|
|
|
|
// Should return the count of passed tests.
|
|
ctrl.testStatus = 'passed';
|
|
expect(ctrl.getCapabilityTestCount(cap)).toEqual(3);
|
|
|
|
// Should return the count of failed tests.
|
|
ctrl.testStatus = 'not passed';
|
|
expect(ctrl.getCapabilityTestCount(cap)).toEqual(4);
|
|
|
|
// Should return the count of flagged tests.
|
|
ctrl.testStatus = 'flagged';
|
|
expect(ctrl.getCapabilityTestCount(cap)).toEqual(3);
|
|
});
|
|
|
|
it('should have a method to determine how many tests in a status ' +
|
|
'belong under the current test filter',
|
|
function () {
|
|
ctrl.caps = {'required': {'caps': [], 'count': 10,
|
|
'passedCount': 6, 'flagFailCount': 3,
|
|
'flagPassCount': 2}};
|
|
|
|
// Should return the count of all tests (count).
|
|
expect(ctrl.getStatusTestCount('required')).toEqual(10);
|
|
|
|
// Should return the count of passed tests (passedCount).
|
|
ctrl.testStatus = 'passed';
|
|
expect(ctrl.getStatusTestCount('required')).toEqual(6);
|
|
|
|
// Should return the count of failed tests
|
|
// (count - passedCount).
|
|
ctrl.testStatus = 'not passed';
|
|
expect(ctrl.getStatusTestCount('required')).toEqual(4);
|
|
|
|
// Should return the count of flagged tests
|
|
// (flagFailCount + flagPassCount).
|
|
ctrl.testStatus = 'flagged';
|
|
expect(ctrl.getStatusTestCount('required')).toEqual(5);
|
|
|
|
// Test when caps has not been set yet.
|
|
ctrl.caps = null;
|
|
expect(ctrl.getStatusTestCount('required')).toEqual(-1);
|
|
});
|
|
|
|
it('should have a method to update the verification status of a test',
|
|
function () {
|
|
$httpBackend.expectGET(fakeApiUrl +
|
|
'/guidelines').respond(200, {
|
|
'powered': [
|
|
{'name': '2015.03.json', 'file': '2015.03.json'},
|
|
{'name': '2015.04.json', 'file': '2015.04.json'}
|
|
]
|
|
});
|
|
$httpBackend.expectGET(fakeApiUrl +
|
|
'/guidelines/2015.03.json').respond(fakeCapabilityResponse);
|
|
$httpBackend.flush();
|
|
ctrl.isVerified = 1;
|
|
$httpBackend.expectPUT(fakeApiUrl + '/results/1234',
|
|
{'verification_status': ctrl.isVerified}).respond(204, '');
|
|
$httpBackend.when('GET', /\.html$/).respond(200);
|
|
ctrl.updateVerificationStatus();
|
|
$httpBackend.flush();
|
|
expect(ctrl.resultsData.verification_status).toEqual(1);
|
|
|
|
});
|
|
|
|
it('should have a method to open a modal for the full passed test list',
|
|
function () {
|
|
var modal;
|
|
inject(function ($uibModal) {
|
|
modal = $uibModal;
|
|
});
|
|
spyOn(modal, 'open');
|
|
ctrl.openFullTestListModal();
|
|
expect(modal.open).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should have a method to open a modal for editing test metadata',
|
|
function () {
|
|
var modal;
|
|
inject(function ($uibModal) {
|
|
modal = $uibModal;
|
|
});
|
|
spyOn(modal, 'open');
|
|
ctrl.openEditTestModal();
|
|
expect(modal.open).toHaveBeenCalled();
|
|
|
|
});
|
|
});
|
|
|
|
describe('FullTestListModalController', function () {
|
|
var modalInstance, ctrl;
|
|
|
|
beforeEach(inject(function ($controller) {
|
|
modalInstance = {
|
|
dismiss: jasmine.createSpy('modalInstance.dismiss')
|
|
};
|
|
ctrl = $controller('FullTestListModalController',
|
|
{$uibModalInstance: modalInstance, tests: ['t1', 't2'],
|
|
gl_type: 'powered'}
|
|
);
|
|
}));
|
|
|
|
it('should set a scope variable to the passed in tests', function () {
|
|
expect(ctrl.tests).toEqual(['t1', 't2']);
|
|
});
|
|
|
|
it('should have a method to close the modal',
|
|
function () {
|
|
ctrl.close();
|
|
expect(modalInstance.dismiss).toHaveBeenCalledWith('exit');
|
|
});
|
|
|
|
it('should have a method to convert the tests to a string',
|
|
function () {
|
|
ctrl.tests = ['t2', 't1', 't3'];
|
|
var expectedString = 't1\nt2\nt3';
|
|
expect(ctrl.getTestListString()).toEqual(expectedString);
|
|
});
|
|
});
|
|
|
|
describe('EditTestModalController', function () {
|
|
var modalInstance, ctrl, state;
|
|
var fakeResultsData = {
|
|
'results': ['test_id_1'],
|
|
'id': 'some-id',
|
|
'meta': {
|
|
'public_key': 'ssh-rsa', 'guideline': '2015.04.json',
|
|
'target': 'object'
|
|
}
|
|
};
|
|
var fake_gl_type = 'powered';
|
|
var fakeVersionResp = [{'id': 'ver1', 'version': '1.0'},
|
|
{'id': 'ver2', 'version': null}];
|
|
|
|
beforeEach(inject(function ($controller) {
|
|
modalInstance = {
|
|
dismiss: jasmine.createSpy('modalInstance.dismiss')
|
|
};
|
|
state = {
|
|
reload: jasmine.createSpy('state.reload')
|
|
};
|
|
ctrl = $controller('EditTestModalController',
|
|
{$uibModalInstance: modalInstance, $state: state,
|
|
resultsData: fakeResultsData, gl_type: fake_gl_type}
|
|
);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/guidelines').respond({
|
|
'powered': [
|
|
{'name': '2015.03.json', 'file': '2015.03.json'},
|
|
{'name': '2015.04.json', 'file': '2015.04.json'}
|
|
]
|
|
});
|
|
|
|
$httpBackend.when('GET', fakeApiUrl + '/products')
|
|
.respond(200, fakeResultsData);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/products/1234/versions').respond(fakeVersionResp);
|
|
}));
|
|
|
|
it('should be able to get product versions', function () {
|
|
ctrl.selectedProduct = {'id': '1234'};
|
|
ctrl.products = null;
|
|
$httpBackend.expectGET(fakeApiUrl + '/products/1234/versions')
|
|
.respond(200, fakeVersionResp);
|
|
ctrl.getProductVersions();
|
|
$httpBackend.flush();
|
|
expect(ctrl.productVersions).toEqual(fakeVersionResp);
|
|
var expected = {'id': 'ver2', 'version': null};
|
|
expect(ctrl.selectedVersion).toEqual(expected);
|
|
});
|
|
|
|
it('should have a method to save all changes made.', function () {
|
|
ctrl.metaCopy.target = 'platform';
|
|
ctrl.metaCopy.shared = 'true';
|
|
ctrl.selectedVersion = {'id': 'ver2', 'version': null};
|
|
ctrl.saveChanges();
|
|
// Only meta changed should send a POST request.
|
|
$httpBackend.expectPOST(
|
|
fakeApiUrl + '/results/some-id/meta/target',
|
|
'platform')
|
|
.respond(201, '');
|
|
$httpBackend.expectPOST(
|
|
fakeApiUrl + '/results/some-id/meta/shared',
|
|
'true')
|
|
.respond(201, '');
|
|
$httpBackend.expectPUT(fakeApiUrl + '/results/some-id',
|
|
{'product_version_id': 'ver2'})
|
|
.respond(201);
|
|
$httpBackend.flush();
|
|
});
|
|
});
|
|
|
|
describe('TestRaiseAlertModalController', function() {
|
|
var data, modalInstance, ctrl;
|
|
|
|
data = {
|
|
mode: 'success',
|
|
title: '',
|
|
text: 'operation successful'
|
|
};
|
|
|
|
beforeEach(inject(function ($controller) {
|
|
modalInstance = {
|
|
dismiss: jasmine.createSpy('modalInstance.dismiss'),
|
|
close: jasmine.createSpy('modalInstance.close')
|
|
};
|
|
ctrl = $controller('RaiseAlertModalController',
|
|
{$uibModalInstance: modalInstance, data: data}
|
|
);
|
|
}));
|
|
|
|
it('should close',
|
|
function () {
|
|
ctrl.close();
|
|
expect(modalInstance.close).toHaveBeenCalledWith();
|
|
});
|
|
});
|
|
|
|
describe('TestCustomConfirmModalController', function() {
|
|
var data, someFunc, modalInstance, ctrl;
|
|
|
|
beforeEach(inject(function ($controller) {
|
|
modalInstance = {
|
|
dismiss: jasmine.createSpy('modalInstance.dismiss'),
|
|
close: jasmine.createSpy('modalInstance.close')
|
|
};
|
|
|
|
someFunc = jasmine.createSpy('someFunc');
|
|
data = {
|
|
text: 'Some input',
|
|
successHandler: someFunc
|
|
};
|
|
|
|
ctrl = $controller('CustomConfirmModalController',
|
|
{$uibModalInstance: modalInstance, data: data}
|
|
);
|
|
}));
|
|
|
|
it('should have a function to confirm',
|
|
function () {
|
|
ctrl.inputText = 'foo';
|
|
ctrl.confirm();
|
|
expect(someFunc).toHaveBeenCalledWith('foo');
|
|
});
|
|
|
|
it('should have a function to dismiss the modal',
|
|
function () {
|
|
ctrl.cancel();
|
|
expect(modalInstance.dismiss).toHaveBeenCalledWith('cancel');
|
|
});
|
|
});
|
|
|
|
describe('AuthFailureController', function() {
|
|
var $location, ctrl;
|
|
|
|
beforeEach(inject(function ($controller, _$location_) {
|
|
$location = _$location_;
|
|
$location.url('/auth_failure?message=some_error_message');
|
|
ctrl = $controller('AuthFailureController', {});
|
|
}));
|
|
|
|
it('should set the authentication failure url based on error message',
|
|
function () {
|
|
expect($location.url()).toBe('/auth_failure?message=' +
|
|
'some_error_message');
|
|
expect(ctrl.message).toBe('some_error_message');
|
|
});
|
|
});
|
|
|
|
describe('VendorController', function() {
|
|
var rootScope, scope, stateParams, ctrl;
|
|
var confirmModal = jasmine.createSpy('confirmModal');
|
|
var fakeResp = {'id': 'fake-id', 'type': 1,
|
|
'can_manage': true, 'properties' : {}};
|
|
var fakeUsersResp = [{'openid': 'foo'}];
|
|
var fakeProdResp = {'products': [{'id': 123}]};
|
|
var fakeWindow = {
|
|
location: {
|
|
href: ''
|
|
}
|
|
};
|
|
|
|
beforeEach(inject(function ($controller, $rootScope) {
|
|
scope = $rootScope.$new();
|
|
rootScope = $rootScope.$new();
|
|
rootScope.auth = {'currentUser' : {'is_admin': false,
|
|
'openid': 'foo'}
|
|
};
|
|
stateParams = {vendorID: 1234};
|
|
ctrl = $controller('VendorController',
|
|
{$rootScope: rootScope, $scope: scope,
|
|
$stateParams: stateParams, $window: fakeWindow,
|
|
confirmModal: confirmModal}
|
|
);
|
|
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/vendors/1234').respond(fakeResp);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/products?organization_id=1234').respond(fakeProdResp);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/vendors/1234/users').respond(fakeUsersResp);
|
|
}));
|
|
|
|
it('should have a function to get vendor info from API',
|
|
function () {
|
|
ctrl.getVendor();
|
|
$httpBackend.flush();
|
|
expect(ctrl.vendor.id).toEqual('fake-id');
|
|
expect(ctrl.vendor.can_manage).toEqual(true);
|
|
expect(ctrl.vendor.canDelete).toEqual(true);
|
|
expect(ctrl.vendor.canRegister).toEqual(true);
|
|
expect(ctrl.vendor.canApprove).toEqual(false);
|
|
});
|
|
|
|
it('should have a function to get vendor users',
|
|
function () {
|
|
ctrl.getVendorUsers();
|
|
$httpBackend.flush();
|
|
expect(ctrl.vendorUsers).toEqual(fakeUsersResp);
|
|
expect(ctrl.currentUser).toEqual('foo');
|
|
});
|
|
|
|
it('should have a function to get vendor products',
|
|
function () {
|
|
ctrl.vendorProducts = null;
|
|
ctrl.getVendorProducts();
|
|
$httpBackend.flush();
|
|
expect(ctrl.vendorProducts).toEqual(fakeProdResp.products);
|
|
});
|
|
|
|
it('should have a function to register a vendor',
|
|
function () {
|
|
$httpBackend.expectPOST(
|
|
fakeApiUrl + '/vendors/1234/action',
|
|
{'register': null})
|
|
.respond(201, '');
|
|
ctrl.registerVendor();
|
|
$httpBackend.flush();
|
|
});
|
|
|
|
it('should have a function to approve a vendor',
|
|
function () {
|
|
$httpBackend.expectPOST(
|
|
fakeApiUrl + '/vendors/1234/action',
|
|
{'approve': null})
|
|
.respond(201, '');
|
|
ctrl.approveVendor();
|
|
$httpBackend.flush();
|
|
});
|
|
|
|
it('a confirmation modal should come up when declining a vendor',
|
|
function () {
|
|
ctrl.declineVendor();
|
|
expect(confirmModal).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should have a function to delete a vendor',
|
|
function () {
|
|
$httpBackend.expectDELETE(
|
|
fakeApiUrl + '/vendors/1234').respond(202, '');
|
|
ctrl.deleteVendor();
|
|
$httpBackend.flush();
|
|
expect(fakeWindow.location.href).toEqual('/');
|
|
});
|
|
|
|
it('should have to a function to remove a user from a vendor',
|
|
function () {
|
|
var fakeId = 'fake-id';
|
|
$httpBackend.expectDELETE(
|
|
fakeApiUrl + '/vendors/1234/users/' + btoa(fakeId))
|
|
.respond(202, '');
|
|
ctrl.removeUserFromVendor(fakeId);
|
|
$httpBackend.flush();
|
|
});
|
|
|
|
it('should have to a function to add a user to a vendor',
|
|
function () {
|
|
var fakeId = 'fake-id';
|
|
$httpBackend.expectPUT(
|
|
fakeApiUrl + '/vendors/1234/users/' + btoa(fakeId))
|
|
.respond(204, '');
|
|
ctrl.addUserToVendor(fakeId);
|
|
$httpBackend.flush();
|
|
});
|
|
});
|
|
|
|
describe('VendorEditModalController', function() {
|
|
var rootScope, ctrl, modalInstance, state;
|
|
var fakeVendor = {'name': 'Foo', 'description': 'Bar', 'id': '1234',
|
|
'properties': {'key1': 'value1', 'key2': 'value2'}};
|
|
|
|
beforeEach(inject(function ($controller, $rootScope) {
|
|
modalInstance = {
|
|
dismiss: jasmine.createSpy('modalInstance.dismiss')
|
|
};
|
|
state = {
|
|
reload: jasmine.createSpy('state.reload')
|
|
};
|
|
rootScope = $rootScope.$new();
|
|
rootScope.auth = {'currentUser' : {'is_admin': true,
|
|
'openid': 'foo'}
|
|
};
|
|
ctrl = $controller('VendorEditModalController',
|
|
{$rootScope: rootScope,
|
|
$uibModalInstance: modalInstance, $state: state,
|
|
vendor: fakeVendor}
|
|
);
|
|
|
|
}));
|
|
|
|
it('should be able to add/remove properties',
|
|
function () {
|
|
var expected = [{'key': 'key1', 'value': 'value1'},
|
|
{'key': 'key2', 'value': 'value2'}];
|
|
expect(ctrl.vendorProperties).toEqual(expected);
|
|
ctrl.removeProperty(0);
|
|
expected = [{'key': 'key2', 'value': 'value2'}];
|
|
expect(ctrl.vendorProperties).toEqual(expected);
|
|
ctrl.addField();
|
|
expected = [{'key': 'key2', 'value': 'value2'},
|
|
{'key': '', 'value': ''}];
|
|
expect(ctrl.vendorProperties).toEqual(expected);
|
|
});
|
|
|
|
it('should have a function to save changes',
|
|
function () {
|
|
var expectedContent = {
|
|
'name': 'Foo1', 'description': 'Bar',
|
|
'properties': {'key1': 'value1', 'key2': 'value2'}
|
|
};
|
|
$httpBackend.expectPUT(
|
|
fakeApiUrl + '/vendors/1234', expectedContent)
|
|
.respond(200, '');
|
|
ctrl.vendor.name = 'Foo1';
|
|
ctrl.saveChanges();
|
|
$httpBackend.flush();
|
|
});
|
|
|
|
it('should have a function to exit the modal',
|
|
function () {
|
|
ctrl.close();
|
|
expect(modalInstance.dismiss).toHaveBeenCalledWith('exit');
|
|
});
|
|
});
|
|
|
|
describe('VendorsController', function () {
|
|
var rootScope, scope, ctrl;
|
|
var fakeResp = {'vendors': [{'can_manage': true,
|
|
'type': 3,
|
|
'name': 'Foo'},
|
|
{'can_manage': true,
|
|
'type': 3,
|
|
'name': 'Bar'}]};
|
|
beforeEach(inject(function ($controller, $rootScope) {
|
|
scope = $rootScope.$new();
|
|
rootScope = $rootScope.$new();
|
|
rootScope.auth = {'currentUser' : {'is_admin': false,
|
|
'openid': 'foo'}
|
|
};
|
|
ctrl = $controller('VendorsController',
|
|
{$rootScope: rootScope, $scope: scope}
|
|
);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/vendors').respond(fakeResp);
|
|
}));
|
|
|
|
it('should have a function to get a listing of all vendors',
|
|
function () {
|
|
$httpBackend.expectGET(fakeApiUrl + '/vendors')
|
|
.respond(fakeResp);
|
|
ctrl.update();
|
|
$httpBackend.flush();
|
|
expect(ctrl.rawData).toEqual(fakeResp);
|
|
});
|
|
|
|
it('should have a function to update/sort data based on settings',
|
|
function () {
|
|
ctrl.rawData = fakeResp;
|
|
ctrl.updateData();
|
|
var expectedResponse = {'vendors': [{'can_manage': true,
|
|
'type': 3,
|
|
'name' : 'Bar'},
|
|
{'can_manage': true,
|
|
'type': 3,
|
|
'name': 'Foo'}]};
|
|
expect(ctrl.data).toEqual(expectedResponse);
|
|
});
|
|
|
|
it('should have a function to determine if a vendor should be shown',
|
|
function () {
|
|
var fakeVendor = {'type': 0, 'can_manage': false};
|
|
expect(ctrl._filterVendor(fakeVendor)).toEqual(true);
|
|
ctrl.isUserVendors = true;
|
|
expect(ctrl._filterVendor(fakeVendor)).toEqual(false);
|
|
ctrl.isUserVendors = false;
|
|
rootScope.auth.currentUser.is_admin = true;
|
|
expect(ctrl._filterVendor(fakeVendor)).toEqual(true);
|
|
});
|
|
|
|
it('should have a function to add a new vendor',
|
|
function () {
|
|
ctrl.name = 'New Vendor';
|
|
ctrl.description = 'A description';
|
|
$httpBackend.expectPOST(
|
|
fakeApiUrl + '/vendors',
|
|
{name: ctrl.name, description: ctrl.description})
|
|
.respond(200, fakeResp);
|
|
ctrl.addVendor();
|
|
$httpBackend.flush();
|
|
});
|
|
});
|
|
|
|
describe('ProductsController', function() {
|
|
var rootScope, scope, ctrl;
|
|
var vendResp = {'vendors': [{'can_manage': true,
|
|
'type': 3,
|
|
'name': 'Foo',
|
|
'id': '123'}]};
|
|
var prodResp = {'products': [{'id': 'abc',
|
|
'product_type': 1,
|
|
'public': 1,
|
|
'name': 'Foo Product',
|
|
'organization_id': '123'}]};
|
|
|
|
beforeEach(inject(function ($controller, $rootScope) {
|
|
scope = $rootScope.$new();
|
|
rootScope = $rootScope.$new();
|
|
rootScope.auth = {'currentUser' : {'is_admin': false,
|
|
'openid': 'foo'}
|
|
};
|
|
ctrl = $controller('ProductsController',
|
|
{$rootScope: rootScope, $scope: scope}
|
|
);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/vendors').respond(vendResp);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/products').respond(prodResp);
|
|
}));
|
|
|
|
it('should have a function to get/update vendors',
|
|
function () {
|
|
$httpBackend.flush();
|
|
var newVendResp = {'vendors': [{'name': 'Foo',
|
|
'id': '123',
|
|
'can_manage': true},
|
|
{'name': 'Bar',
|
|
'id': '345',
|
|
'can_manage': false}]};
|
|
$httpBackend.expectGET(fakeApiUrl + '/vendors')
|
|
.respond(200, newVendResp);
|
|
ctrl.updateVendors();
|
|
$httpBackend.flush();
|
|
expect(ctrl.allVendors).toEqual({'123': {'name': 'Foo',
|
|
'id': '123',
|
|
'can_manage': true},
|
|
'345': {'name': 'Bar',
|
|
'id': '345',
|
|
'can_manage': false}});
|
|
expect(ctrl.vendors).toEqual([{'name': 'Foo',
|
|
'id': '123',
|
|
'can_manage': true}]);
|
|
});
|
|
|
|
it('should have a function to get products',
|
|
function () {
|
|
$httpBackend.expectGET(fakeApiUrl + '/products')
|
|
.respond(200, prodResp);
|
|
ctrl.update();
|
|
$httpBackend.flush();
|
|
expect(ctrl.rawData).toEqual(prodResp);
|
|
});
|
|
|
|
it('should have a function to update the view',
|
|
function () {
|
|
$httpBackend.flush();
|
|
ctrl.allVendors = {'123': {'name': 'Foo',
|
|
'id': '123',
|
|
'can_manage': true}};
|
|
ctrl.updateData();
|
|
var expectedData = {'products': [{'id': 'abc',
|
|
'product_type': 1,
|
|
'public': 1,
|
|
'name': 'Foo Product',
|
|
'organization_id': '123'}]};
|
|
expect(ctrl.data).toEqual(expectedData);
|
|
});
|
|
|
|
it('should have a function to map product types with descriptions',
|
|
function () {
|
|
expect(ctrl.getProductTypeDescription(0)).toEqual('Distro');
|
|
expect(ctrl.getProductTypeDescription(1))
|
|
.toEqual('Public Cloud');
|
|
expect(ctrl.getProductTypeDescription(2))
|
|
.toEqual('Hosted Private Cloud');
|
|
expect(ctrl.getProductTypeDescription(5)).toEqual('Unknown');
|
|
});
|
|
});
|
|
|
|
describe('ProductController', function() {
|
|
var rootScope, scope, stateParams, ctrl;
|
|
var fakeProdResp = {'product_type': 1,
|
|
'product_ref_id': null,
|
|
'name': 'Good Stuff',
|
|
'created_at': '2016-01-01 01:02:03',
|
|
'updated_at': '2016-06-15 01:02:04',
|
|
'properties': null,
|
|
'organization_id': 'fake-org-id',
|
|
'public': true,
|
|
'can_manage': true,
|
|
'created_by_user': 'fake-open-id',
|
|
'type': 0,
|
|
'id': '1234',
|
|
'description': 'some description'};
|
|
var fakeVersionResp = [{'id': 'asdf',
|
|
'cpid': null,
|
|
'version': '1.0',
|
|
'product_id': '1234'}];
|
|
var fakeTestsResp = {'pagination': {'current_page': 1,
|
|
'total_pages': 1},
|
|
'results':[{'id': 'foo-test'}]};
|
|
var fakeVendorResp = {'id': 'fake-org-id',
|
|
'type': 3,
|
|
'can_manage': true,
|
|
'properties' : {},
|
|
'name': 'Foo Vendor',
|
|
'description': 'foo bar'};
|
|
var fakeWindow = {
|
|
location: {
|
|
href: ''
|
|
}
|
|
};
|
|
|
|
beforeEach(inject(function ($controller, $rootScope) {
|
|
scope = $rootScope.$new();
|
|
rootScope = $rootScope.$new();
|
|
stateParams = {id: 1234};
|
|
rootScope.auth = {'currentUser' : {'is_admin': false,
|
|
'openid': 'foo'}
|
|
};
|
|
ctrl = $controller('ProductController',
|
|
{$rootScope: rootScope, $scope: scope,
|
|
$stateParams: stateParams, $window: fakeWindow}
|
|
);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/products/1234').respond(fakeProdResp);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/products/1234/versions').respond(fakeVersionResp);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/results?page=1&product_id=1234').respond(fakeTestsResp);
|
|
$httpBackend.when('GET', fakeApiUrl +
|
|
'/vendors/fake-org-id').respond(fakeVendorResp);
|
|
}));
|
|
|
|
it('should have a function to get product information',
|
|
function () {
|
|
$httpBackend.expectGET(fakeApiUrl + '/products/1234')
|
|
.respond(200, fakeProdResp);
|
|
$httpBackend.expectGET(fakeApiUrl + '/vendors/fake-org-id')
|
|
.respond(200, fakeVendorResp);
|
|
ctrl.getProduct();
|
|
$httpBackend.flush();
|
|
expect(ctrl.product).toEqual(fakeProdResp);
|
|
expect(ctrl.vendor).toEqual(fakeVendorResp);
|
|
});
|
|
|
|
it('should have a function to get a list of product versions',
|
|
function () {
|
|
$httpBackend
|
|
.expectGET(fakeApiUrl + '/products/1234/versions')
|
|
.respond(200, fakeVersionResp);
|
|
ctrl.getProductVersions();
|
|
$httpBackend.flush();
|
|
expect(ctrl.productVersions).toEqual(fakeVersionResp);
|
|
});
|
|
|
|
it('should have a function to delete a product',
|
|
function () {
|
|
$httpBackend.expectDELETE(fakeApiUrl + '/products/1234')
|
|
.respond(202, '');
|
|
ctrl.deleteProduct();
|
|
$httpBackend.flush();
|
|
expect(fakeWindow.location.href).toEqual('/');
|
|
});
|
|
|
|
it('should have a function to delete a product version',
|
|
function () {
|
|
$httpBackend
|
|
.expectDELETE(fakeApiUrl + '/products/1234/versions/abc')
|
|
.respond(204, '');
|
|
ctrl.deleteProductVersion('abc');
|
|
$httpBackend.flush();
|
|
});
|
|
|
|
it('should have a function to add a product version',
|
|
function () {
|
|
ctrl.newProductVersion = 'abc';
|
|
$httpBackend.expectPOST(
|
|
fakeApiUrl + '/products/1234/versions',
|
|
{version: 'abc'})
|
|
.respond(200, {'id': 'foo'});
|
|
ctrl.addProductVersion();
|
|
$httpBackend.flush();
|
|
});
|
|
|
|
it('should have a function to get tests on a product',
|
|
function () {
|
|
ctrl.getProductTests();
|
|
$httpBackend.flush();
|
|
expect(ctrl.testsData).toEqual(fakeTestsResp.results);
|
|
expect(ctrl.currentPage).toEqual(1);
|
|
});
|
|
|
|
it('should have a function to unassociate a test from a product',
|
|
function () {
|
|
ctrl.testsData = [{'id': 'foo-test'}];
|
|
$httpBackend.expectPUT(
|
|
fakeApiUrl + '/results/foo-test',
|
|
{product_version_id: null})
|
|
.respond(200, {'id': 'foo-test'});
|
|
ctrl.unassociateTest(0);
|
|
$httpBackend.flush();
|
|
expect(ctrl.testsData).toEqual([]);
|
|
});
|
|
|
|
it('should have a function to switch the publicity of a project',
|
|
function () {
|
|
ctrl.product = {'public': true};
|
|
$httpBackend.expectPUT(fakeApiUrl + '/products/1234',
|
|
{'public': false})
|
|
.respond(200, fakeProdResp);
|
|
ctrl.switchProductPublicity();
|
|
$httpBackend.flush();
|
|
});
|
|
|
|
it('should have a method to open a modal for version management',
|
|
function () {
|
|
var modal;
|
|
inject(function ($uibModal) {
|
|
modal = $uibModal;
|
|
});
|
|
spyOn(modal, 'open');
|
|
ctrl.openVersionModal();
|
|
expect(modal.open).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should have a method to open a modal for product editing',
|
|
function () {
|
|
var modal;
|
|
inject(function ($uibModal) {
|
|
modal = $uibModal;
|
|
});
|
|
spyOn(modal, 'open');
|
|
ctrl.openProductEditModal();
|
|
expect(modal.open).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('ProductVersionModalController', function() {
|
|
|
|
var ctrl, modalInstance, state, parent;
|
|
var fakeVersion = {'id': 'asdf', 'cpid': null,
|
|
'version': '1.0','product_id': '1234'};
|
|
|
|
beforeEach(inject(function ($controller) {
|
|
modalInstance = {
|
|
dismiss: jasmine.createSpy('modalInstance.dismiss')
|
|
};
|
|
parent = {
|
|
deleteProductVersion: jasmine.createSpy('deleteProductVersion')
|
|
};
|
|
ctrl = $controller('ProductVersionModalController',
|
|
{$uibModalInstance: modalInstance, $state: state,
|
|
version: fakeVersion, parent: parent}
|
|
);
|
|
}));
|
|
|
|
it('should have a function to prompt a version deletion',
|
|
function () {
|
|
ctrl.deleteProductVersion();
|
|
expect(parent.deleteProductVersion)
|
|
.toHaveBeenCalledWith('asdf');
|
|
expect(modalInstance.dismiss).toHaveBeenCalledWith('exit');
|
|
});
|
|
|
|
it('should have a function to save changes',
|
|
function () {
|
|
ctrl.version.cpid = 'some-cpid';
|
|
var expectedContent = { 'cpid': 'some-cpid'};
|
|
$httpBackend.expectPUT(
|
|
fakeApiUrl + '/products/1234/versions/asdf',
|
|
expectedContent).respond(200, '');
|
|
ctrl.saveChanges();
|
|
$httpBackend.flush();
|
|
});
|
|
});
|
|
|
|
describe('ProductEditModalController', function() {
|
|
var ctrl, modalInstance, state;
|
|
var fakeProduct = {'name': 'Foo', 'description': 'Bar', 'id': '1234',
|
|
'properties': {'key1': 'value1'}};
|
|
var fakeVersion = {'version': null, 'product_id': '1234',
|
|
'cpid': null, 'id': 'asdf'};
|
|
|
|
beforeEach(inject(function ($controller) {
|
|
modalInstance = {
|
|
dismiss: jasmine.createSpy('modalInstance.dismiss')
|
|
};
|
|
state = {
|
|
reload: jasmine.createSpy('state.reload')
|
|
};
|
|
ctrl = $controller('ProductEditModalController',
|
|
{$uibModalInstance: modalInstance, $state: state,
|
|
product: fakeProduct,
|
|
version: fakeVersion}
|
|
);
|
|
}));
|
|
|
|
it('should be able to add/remove properties',
|
|
function () {
|
|
var expected = [{'key': 'key1', 'value': 'value1'}];
|
|
expect(ctrl.productProperties).toEqual(expected);
|
|
ctrl.removeProperty(0);
|
|
expect(ctrl.productProperties).toEqual([]);
|
|
ctrl.addField();
|
|
expected = [{'key': '', 'value': ''}];
|
|
expect(ctrl.productProperties).toEqual(expected);
|
|
});
|
|
|
|
it('should have a function to save changes',
|
|
function () {
|
|
var expectedContent = {
|
|
'name': 'Foo1', 'description': 'Bar',
|
|
'properties': {'key1': 'value1'}
|
|
};
|
|
var verContent = {'cpid': 'abc'};
|
|
$httpBackend.expectPUT(
|
|
fakeApiUrl + '/products/1234', expectedContent)
|
|
.respond(200, '');
|
|
$httpBackend.expectPUT(
|
|
fakeApiUrl + '/products/1234/versions/asdf', verContent)
|
|
.respond(200, '');
|
|
ctrl.productVersion.cpid = 'abc';
|
|
ctrl.product.name = 'Foo1';
|
|
ctrl.saveChanges();
|
|
$httpBackend.flush();
|
|
});
|
|
|
|
it('should have a function to exit the modal',
|
|
function () {
|
|
ctrl.close();
|
|
expect(modalInstance.dismiss).toHaveBeenCalledWith('exit');
|
|
});
|
|
});
|
|
});
|