@webex/webex-core 3.10.0 → 3.11.0

package/test/unit/spec/interceptors/redirect.js

@@ -168,6 +168,104 @@ describe('webex-core', () => {
             uri: 'http://newlocus.example.com',
           });
         });
+
+        it('removes authorization header when redirecting preJoin request to webex-appapi-service', () => {
+          const response = {
+            statusCode: 404,
+            headers: {},
+            body: {
+              code: 404100,
+              data: {
+                siteFullUrl: 'newlocus.example.com'
+              },
+            },
+          };
+
+          const options = {
+            $redirectCount: 0,
+            uri: 'https://test.webex.com/meet/v1/preJoin',
+            resource: 'preJoin',
+            service: 'webex-appapi-service',
+            headers: {
+              authorization: 'Bearer token123',
+            },
+          };
+
+          interceptor.onResponse(options, response);
+          sinon.assert.calledWith(webex.request, sinon.match({
+            $redirectCount: 1,
+            uri: 'https://newlocus.example.com/meet/v1/preJoin',
+            resource: 'preJoin',
+            service: 'webex-appapi-service',
+            headers: {
+              authorization: false,
+            },
+          }));
+        });
+
+        it('keeps authorization header for non-preJoin requests on appapi redirect', () => {
+          const response = {
+            statusCode: 404,
+            headers: {},
+            body: {
+              code: 404100,
+              data: {
+                siteFullUrl: 'newlocus.example.com'
+              },
+            },
+          };
+
+          const options = {
+            $redirectCount: 0,
+            uri: 'https://test.webex.com/meet/v1/join',
+            resource: 'join',
+            service: 'webex-appapi-service',
+            headers: {
+              authorization: 'Bearer token123',
+            },
+          };
+
+          interceptor.onResponse(options, response);
+          sinon.assert.calledWith(webex.request, sinon.match({
+            $redirectCount: 1,
+            uri: 'https://newlocus.example.com/meet/v1/join',
+            headers: {
+              authorization: 'Bearer token123',
+            },
+          }));
+        });
+
+        it('keeps authorization header for preJoin requests to non-webex-appapi-service', () => {
+          const response = {
+            statusCode: 404,
+            headers: {},
+            body: {
+              code: 404100,
+              data: {
+                siteFullUrl: 'newlocus.example.com'
+              },
+            },
+          };
+
+          const options = {
+            $redirectCount: 0,
+            uri: 'https://test.webex.com/meet/v1/preJoin',
+            resource: 'preJoin',
+            service: 'other-service',
+            headers: {
+              authorization: 'Bearer token123',
+            },
+          };
+
+          interceptor.onResponse(options, response);
+          sinon.assert.calledWith(webex.request, sinon.match({
+            $redirectCount: 1,
+            uri: 'https://newlocus.example.com/meet/v1/preJoin',
+            headers: {
+              authorization: 'Bearer token123',
+            },
+          }));
+        });
       });
     });
   });

package/test/unit/spec/services/service-url.js

@@ -151,6 +151,116 @@ describe('webex-core', () => {
 
         assert.isTrue(homeClusterUrls.every((host) => !host.failed));
       });
+
+      describe('when hosts have negative priorities', () => {
+        it('should return defaultUrl when all hosts have negative priorities', () => {
+          const negativeServiceUrl = new ServiceUrl({
+            defaultUrl: 'https://default.example.com/api/v1',
+            hosts: [
+              {
+                host: 'example-host-neg1.com',
+                priority: -1,
+                ttl: -1,
+                id: '1',
+                homeCluster: true,
+              },
+              {
+                host: 'example-host-neg2.com',
+                priority: -1,
+                ttl: -1,
+                id: '2',
+                homeCluster: true,
+              },
+            ],
+            name: 'negative-priority-test',
+          });
+
+          assert.equal(
+            negativeServiceUrl._getPriorityHostUrl(),
+            'https://default.example.com/api/v1'
+          );
+        });
+
+        it('should return defaultUrl when all hosts have zero priority', () => {
+          const zeroServiceUrl = new ServiceUrl({
+            defaultUrl: 'https://default.example.com/api/v1',
+            hosts: [
+              {
+                host: 'example-host-zero.com',
+                priority: 0,
+                ttl: -1,
+                id: '1',
+                homeCluster: true,
+              },
+            ],
+            name: 'zero-priority-test',
+          });
+
+          assert.equal(zeroServiceUrl._getPriorityHostUrl(), 'https://default.example.com/api/v1');
+        });
+
+        it('should ignore hosts with negative priorities and return valid host', () => {
+          const mixedServiceUrl = new ServiceUrl({
+            defaultUrl: 'https://default.example.com/api/v1',
+            hosts: [
+              {
+                host: 'example-host-neg.com',
+                priority: -1,
+                ttl: -1,
+                id: '1',
+                homeCluster: true,
+              },
+              {
+                host: 'example-host-valid.com',
+                priority: 5,
+                ttl: -1,
+                id: '2',
+                homeCluster: true,
+              },
+            ],
+            name: 'mixed-priority-test',
+          });
+
+          const result = mixedServiceUrl._getPriorityHostUrl();
+
+          assert.include(result, 'example-host-valid.com');
+          assert.notInclude(result, 'example-host-neg.com');
+        });
+
+        it('should select lowest positive priority host when mixed with negative priorities', () => {
+          const mixedServiceUrl = new ServiceUrl({
+            defaultUrl: 'https://default.example.com/api/v1',
+            hosts: [
+              {
+                host: 'example-host-neg.com',
+                priority: -1,
+                ttl: -1,
+                id: '1',
+                homeCluster: true,
+              },
+              {
+                host: 'example-host-p5.com',
+                priority: 5,
+                ttl: -1,
+                id: '2',
+                homeCluster: true,
+              },
+              {
+                host: 'example-host-p2.com',
+                priority: 2,
+                ttl: -1,
+                id: '3',
+                homeCluster: true,
+              },
+            ],
+            name: 'mixed-priority-test',
+          });
+
+          const result = mixedServiceUrl._getPriorityHostUrl();
+
+          assert.include(result, 'example-host-p2.com');
+        });
+      });
     });
 
     describe('#failHost()', () => {

package/test/unit/spec/services/services.js

@@ -349,8 +349,6 @@ describe('webex-core', () => {
         
         const mapResult = await services._fetchNewServiceHostmap({from: 'limited'});
 
-        assert.deepEqual(mapResult, mapResponse);
-
         assert.calledOnceWithExactly(services.request, {
           method: 'GET',
           service: 'u2c',
@@ -839,6 +837,417 @@ describe('webex-core', () => {
         assert.equal(webex.config.credentials.authorizeUrl, authUrl);
       });
     });
+    
+    describe('#getMobiusClusters', () => {
+      it('returns unique mobius host entries from hostCatalog', () => {
+        // Arrange: two hostCatalog keys, with duplicate mobius host across keys
+        services._hostCatalog = {
+          'mobius-us-east-2.prod.infra.webex.com': [
+            {host: 'mobius-us-east-2.prod.infra.webex.com', ttl: -1, priority: 5, id: 'urn:TEAM:xyz:mobius'},
+            {host: 'mobius-eu-central-1.prod.infra.webex.com', ttl: -1, priority: 10, id: 'urn:TEAM:xyz:mobius'},
+            ],
+
+          'mobius-eu-central-1.prod.infra.webex.com': [
+            {host: 'mobius-us-east-2.prod.infra.webex.com', ttl: -1, priority: 7, id: 'urn:TEAM:xyz:mobius'}, // duplicate host
+            ],
+          'wdm-a.webex.com' : [
+            {host: 'wdm-a.webex.com', ttl: -1, priority: 5, id: 'urn:TEAM:xyz:wdm'},
+          ]
+        };
+    
+        // Act
+        const clusters = services.getMobiusClusters();
+    
+        // Assert
+        // deduped; only mobius entries; keeps first seen mobius-a, then mobius-b
+        assert.deepEqual(
+          clusters.map(({host, id, ttl, priority}) => ({host, id, ttl, priority})),
+          [
+            {host: 'mobius-us-east-2.prod.infra.webex.com', id: 'urn:TEAM:xyz:mobius', ttl: -1, priority: 5},
+            {host: 'mobius-eu-central-1.prod.infra.webex.com', id: 'urn:TEAM:xyz:mobius', ttl: -1, priority: 10},
+          ]
+        );
+      });
+    });
+
+    describe('#isValidHost', () => {
+      beforeEach(() => {
+        // Setting up a mock host catalog
+          services._hostCatalog = {
+            "audit-ci-m.wbx2.com": [
+              {
+                  "host": "audit-ci-m.wbx2.com",
+                  "ttl": -1,
+                  "priority": 5,
+                  "id": "urn:IDENTITY:PA61:adminAudit"
+              },
+              {
+                  "host": "audit-ci-m.wbx2.com",
+                  "ttl": -1,
+                  "priority": 5,
+                  "id": "urn:IDENTITY:PA61:adminAuditV2"
+              }
+            ],
+            "mercury-connection-partition0-r.wbx2.com": [
+                {
+                    "host": "mercury-connection-partition0-r.wbx2.com",
+                    "ttl": -1,
+                    "priority": 5,
+                    "id": "urn:TEAM:us-west-2_r:mercuryConnectionPartition0"
+                }
+            ],
+            "empty.com": []
+          };
+      });
+      afterAll(() => {
+        // Clean up the mock host catalog
+        services._hostCatalog = {};
+      });
+      it('returns true if the host is in the host catalog', () => {
+        assert.isTrue(services.isValidHost('mercury-connection-partition0-r.wbx2.com'));
+      });
+
+      it('returns false if the host is not in the host catalog or has an empty entry list', () => {
+        assert.isFalse(services.isValidHost('test.com'));
+        assert.isFalse(services.isValidHost(''));
+        assert.isFalse(services.isValidHost(null));
+        assert.isFalse(services.isValidHost(undefined));
+        assert.isFalse(services.isValidHost('empty.com'));
+      });
+
+      it('returns false for non-string inputs', () => {
+        assert.isFalse(services.isValidHost(123));
+        assert.isFalse(services.isValidHost({}));
+        assert.isFalse(services.isValidHost([]));
+      });
+    });
+
+    describe('U2C catalog cache behavior', () => {
+      let webex;
+      let services;
+      let catalog;
+      let localStorageBackup;
+      let windowBackup;
+  
+      const makeLocalStorageShim = () => {
+        const store = new Map();
+        return {
+          getItem: (k) => (store.has(k) ? store.get(k) : null),
+          setItem: (k, v) => store.set(k, v),
+          removeItem: (k) => store.delete(k),
+          _store: store,
+        };
+      };
+  
+      beforeEach(() => {
+        // Build a fresh webex instance
+        webex = new MockWebex({children: {services: Services}, config: {credentials: {federation: true}}});
+        services = webex.internal.services;
+        catalog = services._getCatalog();
+  
+        // enable U2C caching feature flag in tests that rely on localStorage writes/reads
+        services.webex.config = services.webex.config || {};
+        services.webex.config.calling = {...(services.webex.config.calling || {}), cacheU2C: true};
+
+        // stub window.localStorage
+        windowBackup = global.window;
+        if (!global.window) global.window = {};
+        localStorageBackup = global.window.localStorage;
+        global.window.localStorage = makeLocalStorageShim();
+        // Ensure code under test uses our shim via util method
+        sinon.stub(services, '_getLocalStorageSafe').returns(global.window.localStorage);
+  
+        // Stub the formatter so we don't need a full hostmap payload in tests
+        sinon.stub(services, '_formatReceivedHostmap').callsFake(() => [
+          {name: 'hydra', defaultUrl: 'https://api.ciscospark.com/v1', hosts: []},
+        ]);
+      });
+  
+      afterEach(() => {
+        global.window.localStorage = localStorageBackup || undefined;
+        if (!windowBackup) {
+          delete global.window;
+        } else {
+          global.window = windowBackup;
+        }
+        // Restore util stub if present
+        if (services._getLocalStorageSafe && services._getLocalStorageSafe.restore) {
+          services._getLocalStorageSafe.restore();
+        }
+      });
+  
+      it('invokes initServiceCatalogs on ready, caches catalog, and stores in localStorage', async () => {
+        // Arrange: authenticated credentials and spies
+        services.webex.credentials = {
+          getOrgId: sinon.stub().returns('urn:EXAMPLE:org'),
+          canAuthorize: true,
+          supertoken: {access_token: 'token'},
+        };
+        const initSpy = sinon.spy(services, 'initServiceCatalogs');
+        const cacheSpy = sinon.spy(services, '_cacheCatalog');
+        const setItemSpy = sinon.spy(global.window.localStorage, 'setItem');
+        // Make fetch return a hostmap object and allow formatter to reduce it
+        sinon.stub(services, 'request').resolves({body: {services: [], activeServices: {}, timestamp: Date.now().toString(), orgId: 'urn:EXAMPLE:org', format: 'U2CV2'}});
+        // Cause ready callback to run immediately
+        services.listenToOnce = sinon.stub().callsFake((ctx, event, cb) => {
+          if (event === 'ready') cb();
+        });
+
+        // Act
+        services.initialize();
+        await waitForAsync();
+
+        // Assert: initServiceCatalogs was called because there was no cache
+        assert.isTrue(initSpy.called, 'expected initServiceCatalogs to be invoked on ready');
+        // _cacheCatalog is called at least once (preauth/postauth flows)
+        assert.isTrue(cacheSpy.called, 'expected _cacheCatalog to be called');
+        assert.isTrue(setItemSpy.called, 'expected localStorage.setItem to be called');
+
+        // Cleanup spies
+        services.request.restore();
+        initSpy.restore();
+        cacheSpy.restore();
+        setItemSpy.restore();
+      });
+
+      it('does not invoke initServiceCatalogs on ready when cache exists and uses cached catalog', async () => {
+        // Arrange: put a valid cache
+        const CATALOG_CACHE_KEY_V1 = 'services.v1.u2cHostMap';
+        const cached = {
+          orgId: 'urn:EXAMPLE:org',
+          cachedAt: Date.now(),
+          preauth: {serviceLinks: {}, hostCatalog: {}},
+          postauth: {serviceLinks: {}, hostCatalog: {}},
+        };
+        global.window.localStorage.setItem(CATALOG_CACHE_KEY_V1, JSON.stringify(cached));
+
+        // authenticated credentials
+        services.webex.credentials = {
+          getOrgId: sinon.stub().returns('urn:EXAMPLE:org'),
+          canAuthorize: true,
+          supertoken: {access_token: 'token'},
+        };
+
+        const initSpy = sinon.spy(services, 'initServiceCatalogs');
+        const cacheSpy = sinon.spy(services, '_cacheCatalog');
+        // Cause ready callback to run immediately
+        services.listenToOnce = sinon.stub().callsFake((ctx, event, cb) => {
+          if (event === 'ready') cb();
+        });
+
+        // Act
+        services.initialize();
+        await waitForAsync();
+
+        // Assert: ready path found cache and skipped initServiceCatalogs
+        assert.isFalse(initSpy.called, 'expected initServiceCatalogs to be skipped with cache present');
+        assert.isTrue(services._getCatalog().status.preauth.ready, 'preauth should be ready from cache');
+        assert.isTrue(services._getCatalog().status.postauth.ready, 'postauth should be ready from cache');
+        assert.isFalse(cacheSpy.called, 'should not write cache during warm-up-only path');
+
+        // Cleanup
+        initSpy.restore();
+        cacheSpy.restore();
+      });
+
+      it('expires cached catalog after TTL and clears the entry', async () => {
+        const CATALOG_CACHE_KEY_V1 = 'services.v1.u2cHostMap';
+        const staleCached = {
+          orgId: 'urn:EXAMPLE:org',
+          cachedAt: Date.now() - (24 * 60 * 60 * 1000 + 1000), // past TTL
+          preauth: {serviceLinks: {}, hostCatalog: {}},
+          postauth: {serviceLinks: {}, hostCatalog: {}},
+        };
+  
+        window.localStorage.setItem(CATALOG_CACHE_KEY_V1, JSON.stringify(staleCached));
+  
+        const warmed = await services._loadCatalogFromCache();
+  
+        assert.isFalse(warmed, 'stale cache must not warm');
+        assert.isNull(window.localStorage.getItem(CATALOG_CACHE_KEY_V1), 'expired cache must be cleared');
+        assert.isFalse(catalog.status.preauth.ready);
+        assert.isFalse(catalog.status.postauth.ready);
+      });
+  
+      it('clearCatalogCache() removes the cached entry', async () => {
+        const CATALOG_CACHE_KEY_V1 = 'services.v1.u2cHostMap';
+        window.localStorage.setItem(CATALOG_CACHE_KEY_V1, JSON.stringify({cachedAt: Date.now()}));
+  
+        await services.clearCatalogCache();
+  
+        assert.isNull(window.localStorage.getItem(CATALOG_CACHE_KEY_V1), 'cache should be cleared');
+      });
+  
+      it('still fetches when forceRefresh=true even if ready', async () => {
+        const CATALOG_CACHE_KEY_V1 = 'services.v1.u2cHostMap';
+        window.localStorage.setItem(
+          CATALOG_CACHE_KEY_V1,
+          JSON.stringify({
+            orgId: 'urn:EXAMPLE:org',
+            cachedAt: Date.now(),
+            preauth: {serviceLinks: {}, hostCatalog: {}},
+            postauth: {serviceLinks: {}, hostCatalog: {}},
+          })
+        );
+  
+        // warm from cache
+        const warmed = await services._loadCatalogFromCache();
+        assert.isTrue(warmed);
+        assert.isTrue(catalog.status.preauth.ready);
+        assert.isTrue(catalog.status.postauth.ready);
+  
+        const fetchSpy = sinon.spy(services, '_fetchNewServiceHostmap');
+  
+        // with forceRefresh we should fetch despite ready=true
+        await services.updateServices({from: 'limited', query: {orgId: 'urn:EXAMPLE:org'}, forceRefresh: true});
+        // pass an empty query to avoid spreading undefined in qs construction
+        await services.updateServices({forceRefresh: true});
+  
+        assert.isTrue(fetchSpy.called, 'forceRefresh should bypass cache short-circuit');
+        fetchSpy.restore();
+      });
+
+      it('stores selection metadata and env on cache write for preauth', async () => {
+        const CATALOG_CACHE_KEY_V1 = 'services.v1.u2cHostMap';
+        // arrange config for env fingerprint
+        services.webex.config = services.webex.config || {};
+        services.webex.config.services = services.webex.config.services || {discovery: {}};
+        services.webex.config.services.discovery.u2c = 'https://u2c.wbx2.com/u2c/api/v1';
+        services.webex.config.fedramp = false;
+
+        // write cache with meta
+        await services._cacheCatalog(
+          'preauth',
+          {serviceLinks: {}, hostCatalog: {}},
+          {selectionType: 'orgId', selectionValue: 'urn:EXAMPLE:org'}
+        );
+
+        const raw = window.localStorage.getItem(CATALOG_CACHE_KEY_V1);
+        assert.isString(raw);
+        const parsed = JSON.parse(raw);
+        assert.equal(parsed.orgId, undefined, 'orgId not set without credentials');
+        assert.deepEqual(parsed.env, {
+          fedramp: false,
+          u2cDiscoveryUrl: 'https://u2c.wbx2.com/u2c/api/v1',
+        });
+        assert.isObject(parsed.preauth);
+        assert.deepEqual(parsed.preauth.meta, {
+          selectionType: 'orgId',
+          selectionValue: 'urn:EXAMPLE:org',
+        });
+      });
+
+      it('warms preauth from cache when selection meta matches intended orgId', async () => {
+        const CATALOG_CACHE_KEY_V1 = 'services.v1.u2cHostMap';
+        // stub credentials
+        services.webex.credentials = {
+          canAuthorize: true,
+          getOrgId: sinon.stub().returns('urn:EXAMPLE:org'),
+        };
+        // set current env to match cached env
+        services.webex.config = services.webex.config || {};
+        services.webex.config.services = services.webex.config.services || {discovery: {}};
+        services.webex.config.services.discovery.u2c = 'https://u2c.wbx2.com/u2c/api/v1';
+        services.webex.config.fedramp = false;
+        // cache with matching orgId selection
+        window.localStorage.setItem(
+          CATALOG_CACHE_KEY_V1,
+          JSON.stringify({
+            cachedAt: Date.now(),
+            env: {fedramp: false, u2cDiscoveryUrl: 'https://u2c.wbx2.com/u2c/api/v1'},
+            preauth: {
+              hostMap: {serviceLinks: {}, hostCatalog: {}},
+              meta: {selectionType: 'orgId', selectionValue: 'urn:EXAMPLE:org'},
+            },
+          })
+        );
+        // formatter returns at least one entry to mark ready
+        services._formatReceivedHostmap.restore && services._formatReceivedHostmap.restore();
+        sinon.stub(services, '_formatReceivedHostmap').callsFake(() => [
+          {name: 'hydra', defaultUrl: 'https://api.ciscospark.com/v1', hosts: []},
+        ]);
+
+        const warmed = await services._loadCatalogFromCache();
+        assert.isTrue(warmed);
+        assert.isTrue(catalog.status.preauth.ready, 'preauth should be warmed on match');
+      });
+
+      it('does not warm preauth when selection meta is proximity mode', async () => {
+        const CATALOG_CACHE_KEY_V1 = 'services.v1.u2cHostMap';
+        // cache with proximity mode selection
+        window.localStorage.setItem(
+          CATALOG_CACHE_KEY_V1,
+          JSON.stringify({
+            cachedAt: Date.now(),
+            env: {fedramp: false, u2cDiscoveryUrl: 'https://u2c.wbx2.com/u2c/api/v1'},
+            preauth: {
+              hostMap: {serviceLinks: {}, hostCatalog: {}},
+              meta: {selectionType: 'mode', selectionValue: 'DEFAULT_BY_PROXIMITY'},
+            },
+          })
+        );
+        services._formatReceivedHostmap.restore && services._formatReceivedHostmap.restore();
+        sinon.stub(services, '_formatReceivedHostmap').callsFake(() => [
+          {name: 'hydra', defaultUrl: 'https://api.ciscospark.com/v1', hosts: []},
+        ]);
+
+        const warmed = await services._loadCatalogFromCache();
+        // function returns true if overall cache path succeeded; we only verify group readiness
+        assert.isFalse(catalog.status.preauth.ready, 'preauth should not warm for proximity mode');
+      });
+
+      it('does not warm preauth when selection meta mismatches intended selection', async () => {
+        const CATALOG_CACHE_KEY_V1 = 'services.v1.u2cHostMap';
+        // authorized with org X
+        services.webex.credentials = {
+          canAuthorize: true,
+          getOrgId: sinon.stub().returns('urn:EXAMPLE:org'),
+        };
+        // cache points to a different org
+        window.localStorage.setItem(
+          CATALOG_CACHE_KEY_V1,
+          JSON.stringify({
+            cachedAt: Date.now(),
+            env: {fedramp: false, u2cDiscoveryUrl: 'https://u2c.wbx2.com/u2c/api/v1'},
+            preauth: {
+              hostMap: {serviceLinks: {}, hostCatalog: {}},
+              meta: {selectionType: 'orgId', selectionValue: 'urn:DIFF:org'},
+            },
+          })
+        );
+        services._formatReceivedHostmap.restore && services._formatReceivedHostmap.restore();
+        sinon.stub(services, '_formatReceivedHostmap').callsFake(() => [
+          {name: 'hydra', defaultUrl: 'https://api.ciscospark.com/v1', hosts: []},
+        ]);
+
+        await services._loadCatalogFromCache();
+        assert.isFalse(catalog.status.preauth.ready, 'preauth should not warm on selection mismatch');
+      });
+
+      it('skips warming when environment fingerprint mismatches', async () => {
+        const CATALOG_CACHE_KEY_V1 = 'services.v1.u2cHostMap';
+        // cached env differs from current env (different U2C URL)
+        window.localStorage.setItem(
+          CATALOG_CACHE_KEY_V1,
+          JSON.stringify({
+            cachedAt: Date.now(),
+            env: {fedramp: false, u2cDiscoveryUrl: 'https://u2c.other.com/u2c/api/v1'},
+            preauth: {hostMap: {serviceLinks: {}, hostCatalog: {}}, meta: {selectionType: 'mode', selectionValue: 'DEFAULT_BY_PROXIMITY'}},
+          })
+        );
+        // current env
+        services.webex.config = services.webex.config || {};
+        services.webex.config.services = services.webex.config.services || {discovery: {}};
+        services.webex.config.services.discovery.u2c = 'https://u2c.wbx2.com/u2c/api/v1';
+        services.webex.config.fedramp = false;
+
+        const warmed = await services._loadCatalogFromCache();
+        assert.isFalse(warmed, 'env mismatch should skip warm and return false');
+        assert.isFalse(catalog.status.preauth.ready);
+        assert.isFalse(catalog.status.postauth.ready);
+      });
+    });
+    
   });
 });
 /* eslint-enable no-underscore-dangle */