handle selectors with comma

Author: mmalerba

src/cdk-experimental/testing/component-harness.ts

@@ -349,7 +349,9 @@ export class HarnessPredicate<T extends ComponentHarness> {
 
   /** Gets the selector used to find candidate elements. */
   getSelector() {
-    return (this._ancestor ? `${this._ancestor} ` : '') + this.harnessType.hostSelector;
+    return this._ancestor.split(',')
+        .map(part => `${part.trim()} ${this.harnessType.hostSelector}`.trim())
+        .join(',');
   }
 
   /** Adds base options common to all harness types. */

src/cdk-experimental/testing/tests/harnesses/main-component-harness.ts

@@ -52,18 +52,23 @@ export class MainComponentHarness extends ComponentHarness {
   readonly lastList = this.locatorFor(SubComponentHarness.with({selector: ':last-child'}));
   readonly specaialKey = this.locatorFor('.special-key');
 
-  readonly requiredParentRestrictedSubcomponent =
+  readonly requiredAncestorRestrictedSubcomponent =
       this.locatorFor(SubComponentHarness.with({ancestor: '.other'}));
-  readonly optionalParentRestrictedSubcomponent =
+  readonly optionalAncestorRestrictedSubcomponent =
       this.locatorForOptional(SubComponentHarness.with({ancestor: '.other'}));
-  readonly allParentRestrictedSubcomponent =
+  readonly allAncestorRestrictedSubcomponent =
       this.locatorForAll(SubComponentHarness.with({ancestor: '.other'}));
-  readonly requiredParentRestrictedMissingSubcomponent =
+  readonly requiredAncestorRestrictedMissingSubcomponent =
       this.locatorFor(SubComponentHarness.with({ancestor: '.not-found'}));
-  readonly optionalParentRestrictedMissingSubcomponent =
+  readonly optionalAncestorRestrictedMissingSubcomponent =
       this.locatorForOptional(SubComponentHarness.with({ancestor: '.not-found'}));
-  readonly allParentRestrictedMissingSubcomponent =
+  readonly allAncestorRestrictedMissingSubcomponent =
       this.locatorForAll(SubComponentHarness.with({ancestor: '.not-found'}));
+  readonly multipleAncestorSelectorsSubcomponent =
+      this.locatorForAll(SubComponentHarness.with({ancestor: '.other, .subcomponents'}));
+  readonly directAncestorSelectorSubcomponent =
+      this.locatorForAll(SubComponentHarness.with({ancestor: '.other >'}));
+
 
   private _testTools = this.locatorFor(SubComponentHarness);
 

src/cdk-experimental/testing/tests/protractor.e2e.spec.ts

@@ -271,15 +271,15 @@ describe('ProtractorHarnessEnvironment', () => {
       expect(await button.matchesSelector('button:disabled')).toBe(false);
     });
 
-    it('should load required harness with parent selector restriction', async () => {
-      const subcomp = await harness.requiredParentRestrictedSubcomponent();
+    it('should load required harness with ancestor selector restriction', async () => {
+      const subcomp = await harness.requiredAncestorRestrictedSubcomponent();
       expect(await (await subcomp.title()).text()).toBe('List of other 1');
     });
 
-    it('should throw when failing to find required harness with parent selector restriction',
+    it('should throw when failing to find required harness with ancestor selector restriction',
         async () => {
           try {
-            await harness.requiredParentRestrictedMissingSubcomponent();
+            await harness.requiredAncestorRestrictedMissingSubcomponent();
             fail('Expected to throw');
           } catch (e) {
             expect(e.message).toBe(
@@ -289,20 +289,20 @@ describe('ProtractorHarnessEnvironment', () => {
           }
         });
 
-    it('should load optional harness with parent selector restriction', async () => {
+    it('should load optional harness with ancestor selector restriction', async () => {
       const [subcomp1, subcomp2] = await Promise.all([
-        harness.optionalParentRestrictedSubcomponent(),
-        harness.optionalParentRestrictedMissingSubcomponent()
+        harness.optionalAncestorRestrictedSubcomponent(),
+        harness.optionalAncestorRestrictedMissingSubcomponent()
       ]);
       expect(subcomp1).not.toBeNull();
       expect(subcomp2).toBeNull();
       expect(await (await subcomp1!.title()).text()).toBe('List of other 1');
     });
 
-    it('should load all harnesses with parent selector restriction', async () => {
+    it('should load all harnesses with ancestor selector restriction', async () => {
       const [subcomps1, subcomps2] = await Promise.all([
-        harness.allParentRestrictedSubcomponent(),
-        harness.allParentRestrictedMissingSubcomponent()
+        harness.allAncestorRestrictedSubcomponent(),
+        harness.allAncestorRestrictedMissingSubcomponent()
       ]);
       expect(subcomps1.length).toBe(2);
       expect(subcomps2.length).toBe(0);
@@ -311,6 +311,16 @@ describe('ProtractorHarnessEnvironment', () => {
       expect(title1).toBe('List of other 1');
       expect(title2).toBe('List of other 2');
     });
+
+    it('should load all harnesses with multiple ancestor selector restriction', async () => {
+      const subcomps = await harness.multipleAncestorSelectorsSubcomponent();
+      expect(subcomps.length).toBe(4);
+    });
+
+    it('should load all harnesses with direct ancestor selector restriction', async () => {
+      const subcomps = await harness.directAncestorSelectorSubcomponent();
+      expect(subcomps.length).toBe(2);
+    });
   });
 
   describe('HarnessPredicate', () => {

src/cdk-experimental/testing/tests/testbed.spec.ts

@@ -191,15 +191,15 @@ describe('TestbedHarnessEnvironment', () => {
       expect(await specialKey.text()).toBe('alt-j');
     });
 
-    it('should load required harness with parent selector restriction', async () => {
-      const subcomp = await harness.requiredParentRestrictedSubcomponent();
+    it('should load required harness with ancestor selector restriction', async () => {
+      const subcomp = await harness.requiredAncestorRestrictedSubcomponent();
       expect(await (await subcomp.title()).text()).toBe('List of other 1');
     });
 
-    it('should throw when failing to find required harness with parent selector restriction',
+    it('should throw when failing to find required harness with ancestor selector restriction',
         async () => {
           try {
-            await harness.requiredParentRestrictedMissingSubcomponent();
+            await harness.requiredAncestorRestrictedMissingSubcomponent();
             fail('Expected to throw');
           } catch (e) {
             expect(e.message).toBe(
@@ -209,20 +209,20 @@ describe('TestbedHarnessEnvironment', () => {
           }
         });
 
-    it('should load optional harness with parent selector restriction', async () => {
+    it('should load optional harness with ancestor selector restriction', async () => {
       const [subcomp1, subcomp2] = await Promise.all([
-        harness.optionalParentRestrictedSubcomponent(),
-        harness.optionalParentRestrictedMissingSubcomponent()
+        harness.optionalAncestorRestrictedSubcomponent(),
+        harness.optionalAncestorRestrictedMissingSubcomponent()
       ]);
       expect(subcomp1).not.toBeNull();
       expect(subcomp2).toBeNull();
       expect(await (await subcomp1!.title()).text()).toBe('List of other 1');
     });
 
-    it('should load all harnesses with parent selector restriction', async () => {
+    it('should load all harnesses with ancestor selector restriction', async () => {
       const [subcomps1, subcomps2] = await Promise.all([
-        harness.allParentRestrictedSubcomponent(),
-        harness.allParentRestrictedMissingSubcomponent()
+        harness.allAncestorRestrictedSubcomponent(),
+        harness.allAncestorRestrictedMissingSubcomponent()
       ]);
       expect(subcomps1.length).toBe(2);
       expect(subcomps2.length).toBe(0);
@@ -231,6 +231,16 @@ describe('TestbedHarnessEnvironment', () => {
       expect(title1).toBe('List of other 1');
       expect(title2).toBe('List of other 2');
     });
+
+    it('should load all harnesses with multiple ancestor selector restriction', async () => {
+      const subcomps = await harness.multipleAncestorSelectorsSubcomponent();
+      expect(subcomps.length).toBe(4);
+    });
+
+    it('should load all harnesses with direct ancestor selector restriction', async () => {
+      const subcomps = await harness.directAncestorSelectorSubcomponent();
+      expect(subcomps.length).toBe(2);
+    });
   });
 
   describe('TestElement', () => {