shaka-player 3.2.9 → 3.2.12

package/.github/workflows/build-and-test.yaml

@@ -38,23 +38,34 @@ jobs:
     needs: lint
     strategy:
       matrix:
-        os: ["ubuntu-latest", "macos-latest", "windows-latest"]
-        browser: ["Chrome", "Firefox", "Edge", "Safari", "Safari-14"]
-        exclude:
-          - os: ubuntu-latest
-            browser: Edge
-          - os: windows-latest
-            browser: Safari
-          - os: windows-latest
-            browser: Safari-14
-          - os: ubuntu-latest
-            browser: Safari
-          - os: ubuntu-latest
-            browser: Safari-14
         include:
           # Run Linux browsers with xvfb, so they're in a headless X session.
+          # Additionally, generate a code coverage report from Linux Chrome.
+          - os: ubuntu-latest
+            browser: Chrome
+            extra_flags: "--use-xvfb --html-coverage-report"
           - os: ubuntu-latest
+            browser: Firefox
             extra_flags: "--use-xvfb"
+
+          - os: macos-latest
+            browser: Chrome
+          - os: macos-latest
+            browser: Firefox
+          - os: macos-latest
+            browser: Edge
+          - os: macos-latest
+            browser: Safari
+          - os: macos-latest
+            browser: Safari-14
+
+          - os: windows-latest
+            browser: Chrome
+          - os: windows-latest
+            browser: Firefox
+          - os: windows-latest
+            browser: Edge
+
       # Disable fail-fast so that one matrix-job failing doesn't make the other
       # ones end early.
       fail-fast: false
@@ -86,10 +97,11 @@ jobs:
         run: |
           # Download Safari 14
           # See also https://www.macupdate.com/app/mac/15675/apple-safari/old-versions
-          curl -Lv https://www.macupdate.com/action/download/63550 > safari-14.1.2.pkg
+          curl -Lv https://www.macupdate.com/action/download/62946 > Safari14.0CatalinaAuto.pkg.zip
 
           # Install Safari 14 to homedir specifically.
-          installer -pkg safari-14.1.2.pkg -target CurrentUserHomeDirectory
+          unzip Safari14.0CatalinaAuto.pkg.zip
+          installer -pkg Safari14.0CatalinaAuto.pkg -target CurrentUserHomeDirectory
 
           # Install a launcher that can execute a shell script to launch this
           npm install karma-script-launcher --save-dev
@@ -113,6 +125,46 @@ jobs:
             --reporters spec --spec-hide-passed \
             ${{ matrix.extra_flags }}
 
+      - name: Find coverage reports
+        id: coverage
+        if: always() # Even on failure of an earlier step.
+        shell: bash
+        run: |
+          # If the "coverage" directory exists...
+          if [ -d coverage ]; then
+            # Find the path to the coverage output folder.  It includes the
+            # exact browser version in the path, so it will vary.
+            coverage_folder="$( (ls -d coverage/* || true) | head -1 )"
+
+            # Build a folder to stage all the coverage artifacts with
+            # predictable paths.  The resulting zip file will not have any
+            # internal directories.
+            mkdir coverage/staging/
+            cp "$coverage_folder"/coverage.json coverage/staging/
+            cp "$coverage_folder"/coverage-details.json coverage/staging/
+            echo "${{ github.event.number }}" > coverage/staging/pr-number.json
+
+            echo "::set-output name=coverage_found::true"
+            echo "Coverage report staged."
+          else
+            echo "No coverage report generated."
+          fi
+
+      - name: Upload coverage reports
+        uses: actions/upload-artifact@v3
+        if: ${{ always() && steps.coverage.outputs.coverage_found }}
+        with:
+          name: coverage
+          # This will create a download called coverage.zip containing all of
+          # these files, with no internal folders.
+          path: |
+            coverage/staging/coverage.json
+            coverage/staging/coverage-details.json
+            coverage/staging/pr-number.json
+          # Since we've already filtered this step for instances where there is
+          # an environment variable set, the file should definitely be there.
+          if-no-files-found: error
+
   build_in_docker:
     # Don't waste time doing a full matrix of test runs when there was an
     # obvious linter error.

package/.github/workflows/compute-incremental-coverage.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+#
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import io
+import json
+import re
+import subprocess
+import zipfile
+
+# TODO(joeyparrish): Figure out how to get karma to output relative paths only.
+def StripGitDir(path):
+  # Strip the path to the git clone, leaving only the source path within the
+  # repo.
+  return re.sub(r'.*?/(lib|ui)/', r'\1/', path)
+
+def RunCommand(args, text=True):
+  proc = subprocess.run(args, capture_output=True, text=text)
+  if proc.returncode != 0:
+    raise RuntimeError("Command failed:", args, proc.stdout, proc.stderr)
+  return proc.stdout
+
+def GitHubApi(repo, path, text=True):
+  args = ["gh", "api", "/repos/%s/%s" % (repo, path)]
+  output = RunCommand(args, text)
+  if text:
+    return json.loads(output)
+  else:
+    return output
+
+def GetCoverageArtifacts(repo, run_id):
+  # Fetch all artifacts from this run ID.
+  api_path = "actions/runs/%s/artifacts" % run_id
+  results = GitHubApi(repo, api_path)["artifacts"]
+  # Get the one that is named "coverage" (should be the only one).
+  artifact = list(filter(lambda x: x["name"] == "coverage", results))[0]
+
+  # Fetch and open the zip file containing the artifacts.
+  api_path = "actions/artifacts/%s/zip" % artifact["id"]
+  zip_data = GitHubApi(repo, api_path, text=False)
+  return zipfile.ZipFile(io.BytesIO(zip_data), 'r')
+
+def CoverageLines(coverage_range):
+  start_line = coverage_range["start"]["line"]
+  end_line = coverage_range["end"]["line"]
+
+  lines = set()
+  for line in range(start_line, end_line + 1):
+    lines.add(line)
+  return lines
+
+class CoverageDetails(object):
+  def __init__(self, file_data):
+    json_data = json.loads(file_data)
+
+    self.files = {}
+
+    # The structure is something like:
+    # {
+    #   "/path/to/lib/player.js": {
+    #     "statementMap": { ... },
+    #     "fnMap": { ... },
+    #     "s": { ... }
+    #   }
+    # }
+    for path, path_data in json_data.items():
+      path = StripGitDir(path)
+
+      statement_to_lines = {}
+      instrumented_lines = set()
+
+      # The function map is a structure to map where each function is in a
+      # source file:
+      # {
+      #   "0": {
+      #     "loc": {
+      #       "start": {
+      #         "line": 7,
+      #         "column": 0
+      #       },
+      #       "end": {
+      #         "line": 8,
+      #         "column": 29
+      #       }
+      #     }
+      #   },
+      #   ...
+      # }
+      # We extract function locations and remove them from statement spans
+      # below, so that we don't count (for example) class declaration statements
+      # as containing all the lines of every method in the class.
+      function_locations = []
+      for key, value in path_data["fnMap"].items():
+        lines = CoverageLines(value["loc"])
+        function_locations.append(lines)
+
+      # The statement map is a structure to map where each statement is in a
+      # source file:
+      # {
+      #   "0": {
+      #     "start": {
+      #       "line": 7,
+      #       "column": 0
+      #     },
+      #     "end": {
+      #       "line": 8,
+      #       "column": 29
+      #     }
+      #   },
+      #   ...
+      # }
+      for key, value in path_data["statementMap"].items():
+        # All the lines of the statement, which may include other functions or
+        # statements.
+        lines = CoverageLines(value)
+
+        # Subtract from that the lines of any function that is a subset of
+        # these lines.  By excluding entire methods before adding back their
+        # child statements, we exclude empty lines in class methods.
+        for function_lines in function_locations:
+          if function_lines < lines:  # strict subset
+            lines -= function_lines  # set subtraction
+
+        # If this statement is inside the range of another statement, remove
+        # this inner range from that outer one.  This is important because loops
+        # and conditional statements contain their inner branches.
+        for older_key, older_lines in statement_to_lines.items():
+          # Check for a proper subset (lines contains all elements of
+          # child_lines, but child_lines is not an equal set).
+          if lines < older_lines:  # strict subset
+            statement_to_lines[older_key] -= lines  # set subtraction
+
+        statement_to_lines[key] = lines
+
+      # Whatever is left in any statement, we count as instrumented.
+      for key, lines in statement_to_lines.items():
+        for line in lines:
+          instrumented_lines.add(line)
+
+      # The "s" field is a map from statement numbers to number of times
+      # executed.
+      executed_lines = set()
+      for key, executed in path_data["s"].items():
+        if executed:
+          for line in statement_to_lines[key]:
+            executed_lines.add(line)
+
+      self.files[path] = {
+        "instrumented": instrumented_lines,
+        "executed": executed_lines,
+      }
+
+class PullRequest(object):
+  def __init__(self, repo, number):
+    data = GitHubApi(repo, "pulls/%d" % number)
+    sha = data["merge_commit_sha"]
+
+    self.number = number
+    self.changes = {}
+
+    files = GitHubApi(repo, "commits/%s" % sha)["files"]
+
+    for file_data in files:
+      # The patch field is missing for binary files.  Skip those.
+      if "patch" not in file_data:
+        continue
+
+      filename = file_data["filename"]
+      patch = file_data["patch"]
+
+      # Parse through the unified diff in "patch" to find the touched line
+      # numbers.
+      touched_lines = []
+      line_number = None
+      for line in patch.split("\n"):
+        if line[0] == "@":
+          # Turns a header like "@@ -749,7 +757,19 @@ foo" into line number 757.
+          # Note that the last part of the new file range could be omitted:
+          # "@@ -0,0 +1 @@ foo"
+          new_file_range = line.split("+")[1].split(" @@")[0]
+          line_number = int(new_file_range.split(",")[0])
+        elif line[0] == " ":
+          line_number += 1
+        elif line[0] == "+":
+          touched_lines.append(line_number)
+          line_number += 1
+
+      self.changes[filename] = touched_lines
+
+def IncrementalCoverage(pr, coverage_details):
+  num_changed = 0
+  num_covered = 0
+
+  for path in pr.changes:
+    if path in coverage_details.files:
+      changed_lines = pr.changes[path]
+      instrumented_lines = coverage_details.files[path]["instrumented"]
+      executed_lines = coverage_details.files[path]["executed"]
+
+      for line in changed_lines:
+        # Only count the instrumented lines, not whitespace or comments.
+        if line in instrumented_lines:
+          num_changed += 1
+          if line in executed_lines:
+            num_covered += 1
+
+  if num_changed == 0:
+    return None
+  return num_covered / num_changed
+
+def main():
+  parser = argparse.ArgumentParser(
+      description="Compute incremental code coverage for a PR",
+      formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+  parser.add_argument(
+      "--repo",
+      required=True,
+      help="The GitHub repo, such as shaka-project/shaka-player")
+  parser.add_argument(
+      "--run-id",
+      required=True,
+      help="The workflow run ID to download coverage data from")
+  args = parser.parse_args()
+
+  artifacts = GetCoverageArtifacts(args.repo, args.run_id)
+  coverage_details = CoverageDetails(artifacts.read("coverage-details.json"))
+  pr_number = json.loads(artifacts.read("pr-number.json"))
+  pr = PullRequest(args.repo, pr_number)
+  coverage = IncrementalCoverage(pr, coverage_details)
+
+  print("::set-output name=pr_number::%d" % pr_number)
+  if coverage is None:
+    print("::set-output name=coverage::No instrumented code was changed.")
+  else:
+    print("::set-output name=coverage::%.2f%%" % (coverage * 100.0))
+
+if __name__ == "__main__":
+  main()

package/.github/workflows/report-incremental-coverage.yaml

@@ -0,0 +1,39 @@
+name: Report Incremental Coverage
+
+# Runs when the build and test workflow completes.  This will run with full
+# privileges, even if the other workflow doesn't.  That allows us to leave PR
+# comments, when we would not be able to do so otherwise.
+on:
+  workflow_run:
+    workflows: [Build and Test PR]
+    types: [completed]
+
+jobs:
+  report:
+    if: ${{ github.event.workflow_run.event == 'pull_request' }}
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Compute incremental code coverage
+        id: compute
+        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        # Fetches the coverage data from the run that triggered the report,
+        # parses it, compares it to the changed lines in the PR, and computes
+        # the incremental code coverage.
+        run: |
+          python .github/workflows/compute-incremental-coverage.py \
+              --repo ${{ github.repository }} \
+              --run-id ${{ github.event.workflow_run.id }}
+
+      - name: Report incremental code coverage
+        uses: thollander/actions-comment-pull-request@686ab1cab89e0f715a44a0d04b9fdfdd4f33d751
+        with:
+          message: "Incremental code coverage: ${{ steps.compute.outputs.coverage }}"
+          comment_includes: "Incremental code coverage: "
+          pr_number: ${{ steps.compute.outputs.pr_number }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/.github/workflows/selenium-lab-tests.yaml

@@ -17,76 +17,224 @@ on:
 concurrency: selenium-lab
 
 jobs:
-  lab-tests:
-    # This is a self-hosted runner in a Docker container, with access to our
-    # lab's Selenium grid on port 4444.
-    runs-on: self-hosted-selenium
+  compute-ref:
+    name: Compute ref
+    runs-on: ubuntu-latest
+    outputs:
+      REF: ${{ steps.compute.outputs.REF }}
 
     steps:
-      # This runs on our self-hosted runner, and the Docker image it is based
-      # on doesn't have GitHub's CLI pre-installed.  This installs it.  Taken
-      # verbatim from the official installation instructions at
-      # https://github.com/cli/cli/blob/trunk/docs/install_linux.md
-      - name: Install GitHub Actions CLI
-        run: |
-          curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
-          echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null
-          sudo apt update
-          sudo apt install gh
-
       - name: Compute ref
+        id: compute
         run: |
           if [[ "${{ github.event.inputs.pr }}" != "" ]]; then
-            echo LAB_TEST_REF="refs/pull/${{ github.event.inputs.pr }}/head" >> $GITHUB_ENV
+            LAB_TEST_REF="refs/pull/${{ github.event.inputs.pr }}/head"
           else
-            echo LAB_TEST_REF="main" >> $GITHUB_ENV
+            LAB_TEST_REF="main"
           fi
+          echo "::set-output name=REF::$LAB_TEST_REF"
+
+  # Configure the build matrix based on our grid's YAML config.
+  # The matrix contents will be computed by this first job and deserialized
+  # into the second job's config.
+  matrix-config:
+    name: Matrix config
+    needs: compute-ref
+    runs-on: ubuntu-latest
+    outputs:
+      INCLUDE: ${{ steps.configure.outputs.INCLUDE }}
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          ref: ${{ needs.compute-ref.REF }}
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Configure build matrix
+        id: configure
+        shell: node {0}
+        run: |
+          const fs = require('fs');
+          const yaml = require(
+              '${{ github.workspace }}/node_modules/js-yaml/index.js');
+
+          const gridBrowserYaml =
+              fs.readFileSync('build/shaka-lab.yaml', 'utf8');
+          const gridBrowserMetadata = yaml.load(gridBrowserYaml);
+
+          const include = [];
+
+          for (const name in gridBrowserMetadata) {
+            if (name == 'vars') {
+              // Skip variable defs in the YAML file
+              continue;
+            }
+            if (!gridBrowserMetadata[name].disabled) {
+              include.push({browser: name});
+            }
+          }
+
+          // Output JSON object consumed by the build matrix below.
+          console.log(`::set-output name=INCLUDE::${ JSON.stringify(include) }`);
+
+          // Log the output, for the sake of debugging this script.
+          console.log({include});
+
+  # Build Shaka Player once, then distribute that build to the runners in the
+  # build matrix.  For N runners, runs N times faster (since all the
+  # self-hosted Selenium jobs are run in containers on one machine).
+  build-shaka:
+    name: Pre-build Player
+    needs: compute-ref
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          ref: ${{ needs.compute-ref.REF }}
+
+      - name: Set commit status to pending
+        uses: ./.github/workflows/custom-actions/set-commit-status
+        with:
+          context: Selenium / Build
+          state: pending
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build Player
+        run: python3 build/all.py
+
+      - name: Store Player build
+        uses: actions/upload-artifact@v3
+        with:
+          name: shaka-player
+          path: dist/
+          retention-days: 1
+
+      - name: Report final commit status
+        # Will run on success or failure, but not if the workflow is cancelled.
+        if: ${{ success() || failure() }}
+        uses: ./.github/workflows/custom-actions/set-commit-status
+        with:
+          context: Selenium / Build
+          state: ${{ job.status }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+  lab-tests:
+    # This is a self-hosted runner in a Docker container, with access to our
+    # lab's Selenium grid on port 4444.
+    runs-on: self-hosted-selenium
+    needs: [compute-ref, build-shaka, matrix-config]
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJSON(needs.matrix-config.outputs.INCLUDE) }}
+    name: ${{ matrix.browser }}
 
+    steps:
       - uses: actions/checkout@v2
         with:
-          ref: ${{ env.LAB_TEST_REF }}
+          ref: ${{ needs.compute-ref.REF }}
 
-      - name: Set Commit Status to Pending
+      - name: Set commit status to pending
         uses: ./.github/workflows/custom-actions/set-commit-status
         with:
-          context: Selenium Lab Tests
+          context: Selenium / ${{ matrix.browser }}
           state: pending
           token: ${{ secrets.GITHUB_TOKEN }}
 
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v3
         with:
           node-version: 16
           registry-url: 'https://registry.npmjs.org'
 
       # The Docker image for this self-hosted runner doesn't contain java.
-      - uses: actions/setup-java@v2
+      - uses: actions/setup-java@v3
         with:
           distribution: zulu
           java-version: 11
 
-      # The Docker image for this self-hosted runner has "python3" but not
-      # plain "python".
-      - name: Build Player
-        run: python3 build/all.py
+      - name: Cache dependencies
+        uses: actions/cache@v3
+        id: npm-cache
+        with:
+          path: node_modules/
+          key: node-${{ hashFiles('package-lock.json') }}
+
+      - name: Install dependencies
+        if: steps.npm-cache.outputs.cache-hit != 'true'
+        run: npm ci
+
+      # Instead of building Shaka N times, build it once and fetch the build to
+      # each Selenium runner in the matrix.
+      - name: Fetch Player build
+        uses: actions/download-artifact@v3
+        with:
+          name: shaka-player
+          path: dist/
 
       # Run tests on the Selenium grid in our lab.  This uses a private
       # hostname and TLS cert to get EME tests working on all platforms
-      # (since EME only works on https or localhost).
+      # (since EME only works on https or localhost).  The variable KARMA_PORT
+      # must be defined by the self-hosted runner, and mapped from the host to
+      # the container.
       - name: Test Player
         run: |
           python3 build/test.py \
+              --no-build \
               --reporters spec --spec-hide-passed \
               --lets-encrypt-folder /etc/shakalab.rocks \
               --hostname karma.shakalab.rocks \
-              --port 61731 \
+              --port $KARMA_PORT \
               --grid-config build/shaka-lab.yaml \
-              --grid-address selenium-grid.lab:4444
+              --grid-address selenium-grid.lab:4444 \
+              --browsers ${{ matrix.browser }} \
+              --html-coverage-report
+
+      - name: Find coverage report (ChromeLinux only)
+        id: coverage
+        # Run even if an earlier step fails, but only on ChromeLinux.
+        if: ${{ always() && matrix.browser == 'ChromeLinux' }}
+        shell: bash
+        run: |
+          # Find the path to the coverage report specifically for Chrome on
+          # Linux.  It includes the exact browser version in the path, so it
+          # will vary.  Having a single path will make the artifact zip
+          # simpler, whereas using a wildcard in the upload step will result
+          # in a zip file with internal directories.
+          coverage_report="$( (ls coverage/Chrome*Linux*/coverage.json || true) | head -1 )"
+
+          # Show what's there, for debugging purposes.
+          ls -l coverage/
+
+          if [ -f "$coverage_report" ]; then
+            echo "Found coverage report: $coverage_report"
+            echo "::set-output name=coverage_report::$coverage_report"
+          else
+            echo "Could not locate coverage report!"
+            exit 1
+          fi
+
+      - name: Upload coverage report (ChromeLinux only)
+        uses: actions/upload-artifact@v3
+        # If there's a coverage report, upload it, even if a previous step
+        # failed.
+        if: ${{ always() && steps.coverage.outputs.coverage_report }}
+        with:
+          # This will create a download called coverage.zip containing only
+          # coverage.json.
+          path: ${{ steps.coverage.outputs.coverage_report }}
+          name: coverage
+          # Since we've already filtered this step for instances where there is
+          # an environment variable set for this, the file should definitely be
+          # there.
+          if-no-files-found: error
 
-      - name: Report Final Commit Status
+      - name: Report final commit status
         # Will run on success or failure, but not if the workflow is cancelled.
         if: ${{ success() || failure() }}
         uses: ./.github/workflows/custom-actions/set-commit-status
         with:
-          context: Selenium Lab Tests
+          context: Selenium / ${{ matrix.browser }}
           state: ${{ job.status }}
           token: ${{ secrets.GITHUB_TOKEN }}