6942868751

Committed 21 Nov 2023 11:02AM UTC coverage: 72.933% (-0.02%) from 72.956%

Build # 6942868751

Build Type

push

github

Committed by

Arun-KumarH

Commit Message

chore: Release v1.2.5 - See CHANGELOG

Run Details

762 of 1131 branches covered (0.0%)

Branch coverage included in aggregate %.

17 of 17 new or added lines in 3 files covered. (100.0%)

1 existing line in 1 file now uncovered.

1329 of 1736 relevant lines covered (76.56%)

62.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.39

/src/core/hierarchicalScope.ts

import * as _ from 'lodash';
import traverse from 'traverse';
import { Logger } from 'winston';
import { AccessController } from '.';
import { Request } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/access_control';
import { Target } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/rule';
import { Attribute } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/attribute';
import { Resource, ContextWithSubResolved } from './interfaces';
import { getAllValues, updateScopedRoles } from './utils';

export const checkHierarchicalScope = async (ruleTarget: Target,
  request: Request, urns: Map<string, string>, accessController: AccessController, logger?: Logger): Promise<boolean> => {
  let scopedRoles = new Map<string, Map<string, string[]>>(); // <role, <scopingEntity, scopingInstances[]>>
  let role: string;
  const totalScopingEntities: string[] = [];
  const ruleSubject = ruleTarget.subjects || [];
  let hierarchicalRoleScopeCheck = 'true';
  // retrieving all role scoping entities from the rule's subject
  for (let attribute of ruleSubject) {
    if (attribute.id == urns.get('role')) {
      role = attribute.value;
      if (!scopedRoles.has(role)) {
        scopedRoles.set(role, new Map<string, string[]>());
      }
    }
    if (attribute.id == urns.get('roleScopingEntity') && !!role) {
      const scopingEntity = attribute.value;

      totalScopingEntities.push(scopingEntity);
      const scopingEntities = scopedRoles.get(role);
      scopingEntities.set(scopingEntity, []);
      scopedRoles.set(role, scopingEntities);
      role = null;
    }
    if (attribute.id === urns.get('hierarchicalRoleScoping')) {
      hierarchicalRoleScopeCheck = attribute.value;
    }
  }

  if (_.isEmpty(totalScopingEntities)) {
    logger.debug('Scoping entity not found in rule subject hence hierarchical scope check not needed');
    return true; // no scoping entities specified in rule, request ignored
  }

  let context = (request as any).context as ContextWithSubResolved;
  if (_.isEmpty(context)) {
    return false; // no context was provided, evaluation fails
  }

  const ctxResources = context.resources || [];
  const reqTarget = request.target;
  let currentResourceEntity: string;
  // iterating through all targeted resources and retrieve relevant owners instances
  for (let attribute of ruleTarget.resources || []) {
    if (attribute?.id == urns.get('entity')) { // resource type found
      logger.debug('Evaluating resource entity match');
      currentResourceEntity = attribute?.value;

      let entitiesMatch = false;
      // iterating request resources to filter all resources of a given type
      for (let requestAttribute of reqTarget.resources || []) {
        if (requestAttribute?.id == attribute?.id && requestAttribute?.value == currentResourceEntity) {
          entitiesMatch = true; // a resource entity that matches the request and the rule's target
        } else if (requestAttribute?.id == attribute?.id) {
          // rule entity, get ruleNS and entityRegexValue for rule
          const value = currentResourceEntity;
          let pattern = value?.substring(value?.lastIndexOf(':') + 1);
          let nsEntityArray = pattern?.split('.');
          // firstElement could be either entity or namespace
          let nsOrEntity = nsEntityArray[0];
          let entityRegexValue = nsEntityArray[nsEntityArray.length - 1];
          let reqNS, ruleNS;
          if (nsOrEntity?.toUpperCase() != entityRegexValue?.toUpperCase()) {
            // rule name space is present
            ruleNS = nsOrEntity?.toUpperCase();
          }

          // request entity, get reqNS and requestEntityValue for request
          let reqValue = requestAttribute?.value;
          const reqAttributeNS = reqValue?.substring(0, reqValue?.lastIndexOf(':'));
          const ruleAttributeNS = value?.substring(0, value?.lastIndexOf(':'));
          // verify namespace before entity name
          if (reqAttributeNS != ruleAttributeNS) {
            entitiesMatch = false;
          }
          let reqPattern = reqValue?.substring(reqValue?.lastIndexOf(':') + 1);
          let reqNSEntityArray = reqPattern?.split('.');
          // firstElement could be either entity or namespace
          let reqNSOrEntity = reqNSEntityArray[0];
          let requestEntityValue = reqNSEntityArray[reqNSEntityArray.length - 1];
          if (reqNSOrEntity?.toUpperCase() != requestEntityValue?.toUpperCase()) {
            // request name space is present
            reqNS = reqNSOrEntity?.toUpperCase();
          }

          if ((reqNS && ruleNS && (reqNS === ruleNS)) || (!reqNS && !ruleNS)) {
            const reExp = new RegExp(entityRegexValue);
            if (requestEntityValue?.match(reExp)) {
              entitiesMatch = true;
            }
          }
        }
        else if (requestAttribute?.id == urns?.get('resourceID') && entitiesMatch) { // resource instance ID of a matching entity
          const instanceID = requestAttribute?.value;
          // found resource instance ID, iterating through the context to check if owners entities match the scoping entities
          let ctxResource: Resource = _.find(ctxResources, ['instance.id', instanceID]);
          // ctxResource = ctxResource.instance;
          if (ctxResource) {
            ctxResource = ctxResource?.instance;
          } else {
            // look up by ID
            ctxResource = _.find(ctxResources, ['id', instanceID]);
          }
          if (ctxResource) {
            const meta = ctxResource.meta;
            if (_.isEmpty(meta) || _.isEmpty(meta.owners)) {
              logger.debug(`Owners information missing for hierarchical scope matching of entity ${attribute.value}, evaluation fails`);
              return false; // no ownership was passed, evaluation fails
            }
            scopedRoles = updateScopedRoles(meta, scopedRoles, urns, totalScopingEntities);
          } else {
            logger.debug('Resource of targeted entity was not provided in context');
            return false; // resource of targeted entity was not provided in context
          }
          // entitiesMatch = false;
        }
      }
    } else if (attribute?.id === urns.get('operation')) {
      logger.debug('Evaluating resource operation match');
      currentResourceEntity = attribute?.value;
      for (let reqAttribute of reqTarget.resources || []) {
        // match Rule resource operation URN and operation name with request resource operation URN and operation name
        if (reqAttribute?.id === attribute?.id && reqAttribute?.value === attribute?.value) {
          if (ctxResources?.length === 1) {
            let meta;
            if (ctxResources[0]?.instance) {
              meta = ctxResources[0]?.instance?.meta;
            } else if (ctxResources[0]?.meta) {
              meta = ctxResources[0].meta;
            }

            if (_.isEmpty(meta) || _.isEmpty(meta.owners)) {
              logger.debug(`Owner information missing for hierarchical scope matching of operation ${attribute.value}, evaluation fails`);
              return false; // no ownership was passed, evaluation fails
            }
            scopedRoles = updateScopedRoles(meta, scopedRoles, urns, totalScopingEntities);
          } else {
            logger.debug('Invalid resource passed', { resource: ctxResources });
            return false;
          }
        }
      }
    }
  }

  if (_.isNil(currentResourceEntity) || _.isEmpty(currentResourceEntity)) {
    logger.debug('No Entity or operation name found');
    return false; // no entity found
  }

  // check if context subject_id contains HR scope if not make request 'createHierarchicalScopes'
  if (context?.subject?.token && _.isEmpty(context.subject.hierarchical_scopes)) {
    context = await accessController.createHRScope(context);
  }

  const roleAssociations = context?.subject?.role_associations;
  if (_.isEmpty(roleAssociations)) {
    logger.debug('Role Associations not found');
    return false; // impossible to evaluate context
  }
  const treeNodes = new Map<string, Map<string, string[]>>(); // <role, <entity, hierarchicalTreeNodes>>

  for (let i = 0; i < roleAssociations.length; i += 1) {
    const role: string = roleAssociations[i].role;
    const attributes: Attribute[] = roleAssociations[i].attributes || [];

    if (scopedRoles.has(role)) {
      const entities = scopedRoles.get(role);
      let scopingEntity: string;
      // let roleSubNodes = []; // sub nodes to be queried in case hierarchical resource is not found
      for (let attribute of attributes) {
        if (attribute.id == urns.get('roleScopingEntity') && entities.has(attribute.value)) {
          scopingEntity = attribute.value;
          if (attribute?.attributes?.length > 0) {
            for (let roleScopeInstObj of attribute.attributes) { // role-attributes-attributes -> roleScopingInstance
              if (roleScopeInstObj.id == urns.get('roleScopingInstance') && !!scopingEntity) {  // if scoping instance is found within the attributes
                const instances = entities.get(scopingEntity);
                if (!_.isEmpty(_.remove(instances, i => i == roleScopeInstObj.value))) { // if any element was removed
                  if (_.isEmpty(instances)) {
                    entities.delete(scopingEntity);
                    if (entities.size == 0) {
                      scopedRoles.delete(role);
                    }
                  }
                } else {
                  if (!treeNodes.has(role)) {
                    treeNodes.set(role, new Map<string, string[]>());
                  }
                  const nodesByEntity = treeNodes.get(role);
                  if (!nodesByEntity.has(scopingEntity)) {
                    nodesByEntity.set(scopingEntity, []);
                  }
                  const nodes = nodesByEntity.get(scopingEntity);
                  nodes.push(roleScopeInstObj.value);
                  nodesByEntity.set(scopingEntity, nodes);
                  treeNodes.set(role, nodesByEntity);
                }
              }
            }
          }
        }
      }
    }
    else {
      if (i == roleAssociations.length - 1 && scopedRoles.size > 0 && treeNodes.size === 0) {
        logger.debug('Subject does not have one of the required roles in its context');
        return false; // user does not have one of the required roles in its context
      }
    }
  }

  let check = scopedRoles.size == 0;
  if (!check && hierarchicalRoleScopeCheck && hierarchicalRoleScopeCheck === 'true') {
    const hierarchicalScopes = context.subject.hierarchical_scopes;
    for (let hierarchicalScope of hierarchicalScopes) {
      let subTreeRole = null;
      let level = -1;
      traverse(hierarchicalScope).forEach(function (node: any): void { // depth-first search
        let subtreeFound = false;
        if (!!node.id) {
          if (level > -1 && this.level >= level) {
            subTreeRole = null;
            level = -1;
          } else {
            if (!subTreeRole) {
              for (let [role, nodes] of treeNodes) {
                for (let [, instances] of nodes) {
                  if (_.includes(instances, node.id)) {
                    subTreeRole = role;
                    subtreeFound = true;
                    break;
                  }
                }
              }
            }
            if (subtreeFound) {
              const entities = scopedRoles.get(subTreeRole);
              let eligibleOrgScopes = [];
              getAllValues(node, eligibleOrgScopes);
              if (entities) {
                for (let [entity, instances] of entities) {
                  for (let instance of instances) {
                    if (eligibleOrgScopes.indexOf(instance) > -1) {
                      instances = instances.filter(e => e != instance);
                    }
                  }
                  if (instances.length === 0) {
                    entities.delete(entity);
                    break;
                  }
                }
              }
              if (entities && entities.size == 0) {
                scopedRoles.delete(subTreeRole);
                if (scopedRoles.size == 0) {
                  check = true;
                  this.stop(); // stopping traversal, no more scoped roles need to be checked
                }
              }
              // inside hierarchical sub
            }
          }
        }
      });
    }
  }

  return check;
};

1	import * as _ from 'lodash';	2✔
2	import traverse from 'traverse';	2✔
3	import { Logger } from 'winston';
4	import { AccessController } from '.';
5	import { Request } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/access_control';
6	import { Target } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/rule';
7	import { Attribute } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/attribute';
8	import { Resource, ContextWithSubResolved } from './interfaces';
9	import { getAllValues, updateScopedRoles } from './utils';	2✔
10
11	export const checkHierarchicalScope = async (ruleTarget: Target,	2✔
12	request: Request, urns: Map<string, string>, accessController: AccessController, logger?: Logger): Promise<boolean> => {
13	let scopedRoles = new Map<string, Map<string, string[]>>(); // <role, <scopingEntity, scopingInstances[]>>	99✔
14	let role: string;
15	const totalScopingEntities: string[] = [];	99✔
16	const ruleSubject = ruleTarget.subjects \|\| [];	99!
17	let hierarchicalRoleScopeCheck = 'true';	99✔
18	// retrieving all role scoping entities from the rule's subject
19	for (let attribute of ruleSubject) {	99✔
20	if (attribute.id == urns.get('role')) {	156✔
21	role = attribute.value;	80✔
22	if (!scopedRoles.has(role)) {	80!
23	scopedRoles.set(role, new Map<string, string[]>());	80✔
24	}
25	}
26	if (attribute.id == urns.get('roleScopingEntity') && !!role) {	156✔
27	const scopingEntity = attribute.value;	65✔
28
29	totalScopingEntities.push(scopingEntity);	65✔
30	const scopingEntities = scopedRoles.get(role);	65✔
31	scopingEntities.set(scopingEntity, []);	65✔
32	scopedRoles.set(role, scopingEntities);	65✔
33	role = null;	65✔
34	}
35	if (attribute.id === urns.get('hierarchicalRoleScoping')) {	156✔
36	hierarchicalRoleScopeCheck = attribute.value;	1✔
37	}
38	}
39
40	if (_.isEmpty(totalScopingEntities)) {	99✔
41	logger.debug('Scoping entity not found in rule subject hence hierarchical scope check not needed');	34✔
42	return true; // no scoping entities specified in rule, request ignored	34✔
43	}
44
45	let context = (request as any).context as ContextWithSubResolved;	65✔
46	if (_.isEmpty(context)) {	65!
47	return false; // no context was provided, evaluation fails	×
48	}
49
50	const ctxResources = context.resources \|\| [];	65!
51	const reqTarget = request.target;	65✔
52	let currentResourceEntity: string;
53	// iterating through all targeted resources and retrieve relevant owners instances
54	for (let attribute of ruleTarget.resources \|\| []) {	65!
55	if (attribute?.id == urns.get('entity')) { // resource type found	99✔
56	logger.debug('Evaluating resource entity match');	64✔
57	currentResourceEntity = attribute?.value;	64✔
58
59	let entitiesMatch = false;	64✔
60	// iterating request resources to filter all resources of a given type
61	for (let requestAttribute of reqTarget.resources \|\| []) {	64!
62	if (requestAttribute?.id == attribute?.id && requestAttribute?.value == currentResourceEntity) {	258✔
63	entitiesMatch = true; // a resource entity that matches the request and the rule's target	64✔
64	} else if (requestAttribute?.id == attribute?.id) {	194✔
65	// rule entity, get ruleNS and entityRegexValue for rule
66	const value = currentResourceEntity;	23✔
67	let pattern = value?.substring(value?.lastIndexOf(':') + 1);	23✔
68	let nsEntityArray = pattern?.split('.');	23✔
69	// firstElement could be either entity or namespace
70	let nsOrEntity = nsEntityArray[0];	23✔
71	let entityRegexValue = nsEntityArray[nsEntityArray.length - 1];	23✔
72	let reqNS, ruleNS;
73	if (nsOrEntity?.toUpperCase() != entityRegexValue?.toUpperCase()) {	23!
74	// rule name space is present
75	ruleNS = nsOrEntity?.toUpperCase();	×
76	}
77
78	// request entity, get reqNS and requestEntityValue for request
79	let reqValue = requestAttribute?.value;	23✔
80	const reqAttributeNS = reqValue?.substring(0, reqValue?.lastIndexOf(':'));	23✔
81	const ruleAttributeNS = value?.substring(0, value?.lastIndexOf(':'));	23✔
82	// verify namespace before entity name
83	if (reqAttributeNS != ruleAttributeNS) {	23!
84	entitiesMatch = false;	×
85	}
86	let reqPattern = reqValue?.substring(reqValue?.lastIndexOf(':') + 1);	23✔
87	let reqNSEntityArray = reqPattern?.split('.');	23✔
88	// firstElement could be either entity or namespace
89	let reqNSOrEntity = reqNSEntityArray[0];	23✔
90	let requestEntityValue = reqNSEntityArray[reqNSEntityArray.length - 1];	23✔
91	if (reqNSOrEntity?.toUpperCase() != requestEntityValue?.toUpperCase()) {	23!
92	// request name space is present
93	reqNS = reqNSOrEntity?.toUpperCase();	×
94	}
95
96	if ((reqNS && ruleNS && (reqNS === ruleNS)) \|\| (!reqNS && !ruleNS)) {	23!
97	const reExp = new RegExp(entityRegexValue);	23✔
98	if (requestEntityValue?.match(reExp)) {	23!
99	entitiesMatch = true;	×
100	}
101	}
102	}
103	else if (requestAttribute?.id == urns?.get('resourceID') && entitiesMatch) { // resource instance ID of a matching entity	171✔
104	const instanceID = requestAttribute?.value;	79✔
105	// found resource instance ID, iterating through the context to check if owners entities match the scoping entities
106	let ctxResource: Resource = _.find(ctxResources, ['instance.id', instanceID]);	79✔
107	// ctxResource = ctxResource.instance;
108	if (ctxResource) {	79!
109	ctxResource = ctxResource?.instance;	×
110	} else {
111	// look up by ID
112	ctxResource = _.find(ctxResources, ['id', instanceID]);	79✔
113	}
114	if (ctxResource) {	79!
115	const meta = ctxResource.meta;	79✔
116	if (_.isEmpty(meta) \|\| _.isEmpty(meta.owners)) {	79!
UNCOV 117	logger.debug(`Owners information missing for hierarchical scope matching of entity ${attribute.value}, evaluation fails`);	×
118	return false; // no ownership was passed, evaluation fails	×
119	}
120	scopedRoles = updateScopedRoles(meta, scopedRoles, urns, totalScopingEntities);	79✔
121	} else {
122	logger.debug('Resource of targeted entity was not provided in context');	×
123	return false; // resource of targeted entity was not provided in context	×
124	}
125	// entitiesMatch = false;
126	}
127	}
128	} else if (attribute?.id === urns.get('operation')) {	35✔
129	logger.debug('Evaluating resource operation match');	1✔
130	currentResourceEntity = attribute?.value;	1✔
131	for (let reqAttribute of reqTarget.resources \|\| []) {	1!
132	// match Rule resource operation URN and operation name with request resource operation URN and operation name
133	if (reqAttribute?.id === attribute?.id && reqAttribute?.value === attribute?.value) {	1!
134	if (ctxResources?.length === 1) {	1!
135	let meta;
136	if (ctxResources[0]?.instance) {	1!
137	meta = ctxResources[0]?.instance?.meta;	×
138	} else if (ctxResources[0]?.meta) {	1!
139	meta = ctxResources[0].meta;	1✔
140	}
141
142	if (_.isEmpty(meta) \|\| _.isEmpty(meta.owners)) {	1!
143	logger.debug(`Owner information missing for hierarchical scope matching of operation ${attribute.value}, evaluation fails`);	×
144	return false; // no ownership was passed, evaluation fails	×
145	}
146	scopedRoles = updateScopedRoles(meta, scopedRoles, urns, totalScopingEntities);	1✔
147	} else {
148	logger.debug('Invalid resource passed', { resource: ctxResources });	×
149	return false;	×
150	}
151	}
152	}
153	}
154	}
155
156	if (_.isNil(currentResourceEntity) \|\| _.isEmpty(currentResourceEntity)) {	65!
157	logger.debug('No Entity or operation name found');	×
158	return false; // no entity found	×
159	}
160
161	// check if context subject_id contains HR scope if not make request 'createHierarchicalScopes'
162	if (context?.subject?.token && _.isEmpty(context.subject.hierarchical_scopes)) {	65!
163	context = await accessController.createHRScope(context);	×
164	}
165
166	const roleAssociations = context?.subject?.role_associations;	65✔
167	if (_.isEmpty(roleAssociations)) {	65!
168	logger.debug('Role Associations not found');	×
169	return false; // impossible to evaluate context	×
170	}
171	const treeNodes = new Map<string, Map<string, string[]>>(); // <role, <entity, hierarchicalTreeNodes>>	65✔
172
173	for (let i = 0; i < roleAssociations.length; i += 1) {	65✔
174	const role: string = roleAssociations[i].role;	65✔
175	const attributes: Attribute[] = roleAssociations[i].attributes \|\| [];	65!
176
177	if (scopedRoles.has(role)) {	65!
178	const entities = scopedRoles.get(role);	65✔
179	let scopingEntity: string;
180	// let roleSubNodes = []; // sub nodes to be queried in case hierarchical resource is not found
181	for (let attribute of attributes) {	65✔
182	if (attribute.id == urns.get('roleScopingEntity') && entities.has(attribute.value)) {	65!
183	scopingEntity = attribute.value;	65✔
184	if (attribute?.attributes?.length > 0) {	65!
185	for (let roleScopeInstObj of attribute.attributes) { // role-attributes-attributes -> roleScopingInstance	65✔
186	if (roleScopeInstObj.id == urns.get('roleScopingInstance') && !!scopingEntity) { // if scoping instance is found within the attributes	67!
187	const instances = entities.get(scopingEntity);	67✔
188	if (!_.isEmpty(_.remove(instances, i => i == roleScopeInstObj.value))) { // if any element was removed	81✔
189	if (_.isEmpty(instances)) {	44✔
190	entities.delete(scopingEntity);	43✔
191	if (entities.size == 0) {	43!
192	scopedRoles.delete(role);	43✔
193	}
194	}
195	} else {
196	if (!treeNodes.has(role)) {	23!
197	treeNodes.set(role, new Map<string, string[]>());	23✔
198	}
199	const nodesByEntity = treeNodes.get(role);	23✔
200	if (!nodesByEntity.has(scopingEntity)) {	23!
201	nodesByEntity.set(scopingEntity, []);	23✔
202	}
203	const nodes = nodesByEntity.get(scopingEntity);	23✔
204	nodes.push(roleScopeInstObj.value);	23✔
205	nodesByEntity.set(scopingEntity, nodes);	23✔
206	treeNodes.set(role, nodesByEntity);	23✔
207	}
208	}
209	}
210	}
211	}
212	}
213	}
214	else {
215	if (i == roleAssociations.length - 1 && scopedRoles.size > 0 && treeNodes.size === 0) {	×
216	logger.debug('Subject does not have one of the required roles in its context');	×
217	return false; // user does not have one of the required roles in its context	×
218	}
219	}
220	}
221
222	let check = scopedRoles.size == 0;	65✔
223	if (!check && hierarchicalRoleScopeCheck && hierarchicalRoleScopeCheck === 'true') {	65✔
224	const hierarchicalScopes = context.subject.hierarchical_scopes;	22✔
225	for (let hierarchicalScope of hierarchicalScopes) {	22✔
226	let subTreeRole = null;	22✔
227	let level = -1;	22✔
228	traverse(hierarchicalScope).forEach(function (node: any): void { // depth-first search	22✔
229	let subtreeFound = false;	66✔
230	if (!!node.id) {	66✔
231	if (level > -1 && this.level >= level) {	34!
232	subTreeRole = null;	×
233	level = -1;	×
234	} else {
235	if (!subTreeRole) {	34✔
236	for (let [role, nodes] of treeNodes) {	28✔
237	for (let [, instances] of nodes) {	24✔
238	if (_.includes(instances, node.id)) {	24✔
239	subTreeRole = role;	21✔
240	subtreeFound = true;	21✔
241	break;	21✔
242	}
243	}
244	}
245	}
246	if (subtreeFound) {	34✔
247	const entities = scopedRoles.get(subTreeRole);	21✔
248	let eligibleOrgScopes = [];	21✔
249	getAllValues(node, eligibleOrgScopes);	21✔
250	if (entities) {	21!
251	for (let [entity, instances] of entities) {	21✔
252	for (let instance of instances) {	21✔
253	if (eligibleOrgScopes.indexOf(instance) > -1) {	24✔
254	instances = instances.filter(e => e != instance);	24✔
255	}
256	}
257	if (instances.length === 0) {	21✔
258	entities.delete(entity);	18✔
259	break;	18✔
260	}
261	}
262	}
263	if (entities && entities.size == 0) {	21✔
264	scopedRoles.delete(subTreeRole);	18✔
265	if (scopedRoles.size == 0) {	18!
266	check = true;	18✔
267	this.stop(); // stopping traversal, no more scoped roles need to be checked	18✔
268	}
269	}
270	// inside hierarchical sub
271	}
272	}
273	}
274	});
275	}
276	}
277
278	return check;	65✔
279	};

restorecommerce / access-control-srv / 6942868751

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous