github.com/web-platform-tests/wpt.fyi@v0.0.0-20240530210107-70cf978996f1/webapp/components/test/wpt-results.html (about)

     1  <!doctype html>
     2  <html>
     3  
     4  <head>
     5    <meta charset="utf-8">
     6    <script src="../../node_modules/@webcomponents/webcomponentsjs/webcomponents-loader.js"></script>
     7    <script src="../../node_modules/wct-browser-legacy/browser.js"></script>
     8  </head>
     9  
    10  <body>
    11    <test-fixture id="wpt-results-fixture">
    12      <template>
    13        <wpt-results></wpt-results>
    14      </template>
    15    </test-fixture>
    16  
    17    <script type="module">
    18  import { WPTResults } from '../../views/wpt-results.js';
    19  import { TEST_RUNS_DATA } from './util/helpers.js';
    20  
    21  suiteSetup(() => {
    22    window.fetch = (url) => {
    23      const href = url instanceof URL ? url.href : 'unknown';
    24      assert.fail('actual', 'expected', `uncaptured fetch: ${href}`);
    25    };
    26  });
    27  
    28  suite('<wpt-results>', () => {
    29    let sandbox, trf = null;
    30  
    31    setup(() => {
    32      sandbox = sinon.sandbox.create();
    33      sandbox.stub(WPTResults.prototype, 'loadData', function() {
    34        this.testRuns = Array.from(TEST_RUNS_DATA);
    35      });
    36      trf = fixture('wpt-results-fixture');
    37      trf.path = '/'; // Override the path computed from the current page.
    38    });
    39  
    40    test('show banner on noResults', (done) => {
    41      trf.loadData();
    42      trf.noResults = true;
    43      flush(() => {
    44        const banner = trf.root.querySelector('info-banner[type="info"]');
    45        expect(banner).to.not.be.null;
    46        done();
    47      });
    48    });
    49  
    50    test('show banner on failedToLoad', (done) => {
    51      trf.resultsLoadFailed = true;
    52      flush(() => {
    53        const banner = trf.root.querySelector('info-banner[type="error"]');
    54        expect(banner).to.not.be.null;
    55        done();
    56      });
    57    });
    58  
    59    suite('WPTResults.prototype.*', () => {
    60      suite('urlToPath()', () => {
    61        test('urlToPath(location Location)', () => {
    62          test('Path regex', () => {
    63            const url = s => new URL(`https://wpt.fyi${s}`);
    64            assert.equal(trf.urlToPath(url('/results/')), '/');
    65            assert.equal(trf.urlToPath(url('/results/abc')), '/abc');
    66            assert.equal(trf.urlToPath(url('/results/abc/')), '/abc');
    67            assert.equal(trf.urlToPath(url('/results/abc/def/')), '/abc/def');
    68            assert.equal(trf.urlToPath(url('/results/abc/def.html')), '/abc/def.html');
    69          });
    70        });
    71      });
    72  
    73      suite('computeDifferences(before, after)', () => {
    74        test('added', () => {
    75          const before = { passes: 0, total: 0 };
    76          const after = { passes: 1, total: 2 };
    77  
    78          trf.diffFilter = 'A';
    79          expect(trf.computeDifferences(before, after)).to.have.members([1, 1, 2]);
    80  
    81          for (const filter of ['C', 'D', 'U']) {
    82            trf.diffFilter = filter;
    83            expect(trf.computeDifferences(before, after)).to.be.undefined;
    84          }
    85        });
    86  
    87        test('deleted', () => {
    88          const before = { passes: 1, total: 2 };
    89          const after = { passes: 0, total: 0 };
    90  
    91          trf.diffFilter = 'D';
    92          expect(trf.computeDifferences(before, after)).to.have.members([0, 0, -2]);
    93  
    94          for (const filter of ['A', 'C', 'U']) {
    95            trf.diffFilter = filter;
    96            expect(trf.computeDifferences(before, after)).to.be.undefined;
    97          }
    98        });
    99  
   100        test('changed', () => {
   101          // 1/2 new tests pass.
   102          const before = { passes: 0, total: 1 };
   103          const after = { passes: 1, total: 3 };
   104  
   105          trf.diffFilter = 'C';
   106          expect(trf.computeDifferences(before, after)).to.have.members([1, 1, 2]);
   107          for (const filter of ['A', 'D', 'U']) {
   108            trf.diffFilter = filter;
   109            expect(trf.computeDifferences(before, after)).to.be.undefined;
   110          }
   111  
   112          // One new pass.
   113          after.passes = 1;
   114          after.total = 1;
   115          trf.diffFilter = 'C';
   116          expect(trf.computeDifferences(before, after)).to.have.members([1, 0, 0]);
   117          for (const filter of ['A', 'D', 'U']) {
   118            trf.diffFilter = filter;
   119            expect(trf.computeDifferences(before, after)).to.be.undefined;
   120          }
   121  
   122          // One new fail (regression) and one extra failing test = 2 regressions.
   123          before.passes = 1;
   124          before.total = 2;
   125          after.passes = 0;
   126          after.total = 3;
   127          trf.diffFilter = 'C';
   128          expect(trf.computeDifferences(before, after)).to.have.members([0, 2, 1]);
   129          for (const filter of ['A', 'D', 'U']) {
   130            trf.diffFilter = filter;
   131            expect(trf.computeDifferences(before, after)).to.be.undefined;
   132          }
   133        });
   134  
   135        test('unchanged', () => {
   136          // 1/2 new tests pass.
   137          const before = { passes: 1, total: 1 };
   138          const after = before;
   139  
   140          trf.diffFilter = 'U';
   141          expect(trf.computeDifferences(before, after)).to.have.members([0, 0, 0]);
   142          for (const filter of ['A', 'C', 'D']) {
   143            trf.diffFilter = filter;
   144            expect(trf.computeDifferences(before, after)).to.be.undefined;
   145          }
   146        });
   147      });
   148  
   149      suite('computeResultsRangeMessage', () => {
   150        test('chrome', () => {
   151          trf.productSpecs = ['chrome', 'firefox'];
   152          expect(trf.resultsRangeMessage).to.contain('chrome, firefox');
   153        });
   154        test('labels', () => {
   155          trf.labels = ['foo'];
   156          expect(trf.resultsRangeMessage).to.contain('with label \'foo\'');
   157          trf.labels = ['foo', 'bar'];
   158          expect(trf.resultsRangeMessage).to.contain('with labels \'foo\', \'bar\'');
   159        });
   160        test('master', () => {
   161          trf.master = true;
   162          expect(trf.resultsRangeMessage).to.contain('master test runs');
   163          expect(trf.resultsRangeMessage).to.not.contain('with label');
   164        });
   165        test('shas', () => {
   166          const sha = '1234567890';
   167          trf.shas = [sha];
   168          expect(trf.resultsRangeMessage).to.contain(`revision ${sha.substr(0, 7)}`);
   169  
   170          const sha2 = 'abcdef1234abcdef1234abcdef1234abcdef1234';
   171          trf.shas = [sha, sha2];
   172          expect(trf.resultsRangeMessage).to.contain(`revisions ${sha.substr(0, 7)}, ${sha2.substr(0, 7)}`);
   173        });
   174      });
   175  
   176      suite('getMetadataUrl()', () => {
   177        test('simple cases', () => {
   178          trf.displayedProducts = [{ browser_name: 'chrome' }, { browser_name: 'safari' }];
   179          const metadataMap = {
   180            '/a.htmlchrome': { 'b': 'foo.com', 'c': 'bar.com', '/': 'test.com' },
   181            '/a/abc/*safari': { '/': 'abc.com' },
   182            '/c.htmlchrome': { 'b': 'foo1.com' },
   183          };
   184  
   185          assert.equal(trf.getMetadataUrl(0, '/a.html', metadataMap), 'test.com');
   186          assert.equal(trf.getMetadataUrl(1, '/a.html', metadataMap), '');
   187          assert.equal(trf.getMetadataUrl(1, '/a/abc', metadataMap), 'abc.com');
   188          assert.equal(trf.getMetadataUrl(0, '/c.html', metadataMap), 'foo1.com');
   189        });
   190      });
   191  
   192      suite('getTestLabel()', () => {
   193        test('simple cases', () => {
   194          trf.displayedProducts = [{ browser_name: 'chrome' }, { browser_name: 'safari' }];
   195          const labelMap = {
   196            '/a.html': 'interop1,interop2',
   197          };
   198  
   199          assert.equal(trf.getTestLabel('/a.html', labelMap), 'interop1,interop2');
   200        });
   201      });
   202    });
   203  
   204    teardown(() => {
   205      sandbox.restore();
   206    });
   207  });
   208  </script>
   209  </body>
   210  
   211  </html>