Removes Lighthouse reports due to Lighthouse v12 removing PWA audits

Author: JudahGabriel

apps/pwabuilder/Frontend/src/script/pages/app-report.ts

@@ -285,11 +285,11 @@ export class AppReport extends LitElement {
   }
 
 analysisCompleted(): void {
-  this.runningTests = false;
-  if(this.analysis && !this.analysis.webManifest) {
-  this.applyManifestContext(this.analysis.url, undefined, undefined);
-}
+   this.runningTests = false;
+   if(this.analysis) {
+    this.applyManifestContext(this.analysis.url, this.analysis.webManifest?.url, this.analysis?.webManifest?.manifestRaw);
   }
+}
 
 analysisFailed(): void {
   this.runningTests = false;

apps/pwabuilder/Models/Analysis.cs

@@ -114,40 +114,6 @@ public bool MeetsRequirementsForStorePackaging()
         return allRequiredFieldsValid;
     }
 
-    /// <summary>
-    /// Updates this analysis's capabilities based on the Lighthouse report.
-    /// </summary>
-    public void ProcessLighthouseReport(LighthouseReport? lighthouseReport)
-    {
-        var offlineCapability = this.Capabilities.First(c => c.Id == PwaCapabilityId.OfflineSupport);
-        var httpsCapability = this.Capabilities.First(c => c.Id == PwaCapabilityId.HasHttps);
-        var noMixedContentCapability = this.Capabilities.First(c => c.Id == PwaCapabilityId.NoMixedContent);
-        var hasManifestCapability = this.Capabilities.First(c => c.Id == PwaCapabilityId.HasManifest);
-
-        // No lighthouse report? Mark these as skipped, and mark the "has manifest" capability as failed if we're still waiting for it.
-        if (lighthouseReport == null)
-        {
-            offlineCapability.Status = PwaCapabilityCheckStatus.Skipped;
-            httpsCapability.Status = PwaCapabilityCheckStatus.Skipped;
-            noMixedContentCapability.Status = PwaCapabilityCheckStatus.Skipped;
-            if (hasManifestCapability.Status == PwaCapabilityCheckStatus.InProgress)
-            {
-                hasManifestCapability.Status = PwaCapabilityCheckStatus.Failed;
-            }
-            return;
-        }
-
-        offlineCapability.Status = lighthouseReport.GetOfflineCapability();
-        httpsCapability.Status = lighthouseReport.GetHttpsCapability();
-        noMixedContentCapability.Status = lighthouseReport.GetNoMixedContentCapability();
-
-        // If the "has manifest" capability is still processing, update it based on the Lighthouse report.
-        if (hasManifestCapability.Status == PwaCapabilityCheckStatus.InProgress)
-        {
-            hasManifestCapability.Status = lighthouseReport.GetHasManifestCapability();
-        }
-    }
-
     /// <summary>
     /// Update this analysis's capabilities based on the provided list.
     /// </summary>

apps/pwabuilder/Models/LighthouseReport.cs

@@ -75,12 +75,12 @@ public PwaCapabilityCheckStatus GetOfflineCapability()
     /// <returns></returns>
     public PwaCapabilityCheckStatus GetHttpsCapability()
     {
-        if (this.HttpsAudit == null)
+        if (this.IsOnHttpsAudit == null)
         {
             return PwaCapabilityCheckStatus.Skipped;
         }
 
-        return this.HttpsAudit.Score == 1 ? PwaCapabilityCheckStatus.Passed : PwaCapabilityCheckStatus.Failed;
+        return this.IsOnHttpsAudit.Score == 1 ? PwaCapabilityCheckStatus.Passed : PwaCapabilityCheckStatus.Failed;
     }
 
     /// <summary>

apps/pwabuilder/Models/PwaCapability.cs

@@ -742,21 +742,6 @@ public static List<PwaCapability> CreateHttpsCapabilities()
                 ImageUrl = null,
                 Category = PwaCapabilityCategory.Https,
                 Status = PwaCapabilityCheckStatus.InProgress
-            },
-            new PwaCapability
-            {
-                Id = PwaCapabilityId.NoMixedContent,
-                Description = "Your PWA should not served both HTTP and HTTPS content. All resources should be served over HTTPS.",
-                TodoAction = "Fix mixed content issues by ensuring all resources are loaded over HTTPS.",
-                Level = PwaCapabilityLevel.Recommended,
-                FeatureName = null,
-                FeatureIcon = null,
-                Field = null,
-                IsFieldExistenceCheck = false,
-                LearnMoreUrl = new Uri("https://web.dev/articles/what-is-mixed-content"),
-                ImageUrl = null,
-                Category = PwaCapabilityCategory.Https,
-                Status = PwaCapabilityCheckStatus.InProgress
             }
         ];
     }

apps/pwabuilder/Models/PwaCapabilityId.cs

@@ -54,7 +54,6 @@ public enum PwaCapabilityId
 
     // Https capabilities
     HasHttps,
-    NoMixedContent,
 
     // General capabilities
     ServesHtml

apps/pwabuilder/Services/AnalysisJobProcessor.cs

@@ -124,14 +124,12 @@ private async Task TryProcessJobAsync(AnalysisJob job, CancellationToken cancelT
 
             // Kick off the independent jobs simultaneously so that our analysis completes faster.
             var generalCapDetectionTask = generalWebAppCapabilityDetector.TryDetectAsync(job.Url, analysisLogger, cancelTokenSrc.Token);
-            var lighthouseAnalysisTask = TryRunLighthouseAudit(job, analysisLogger, cancelTokenSrc.Token);
             var serviceWorkerDetectionTask = serviceWorkerDetector.TryDetectAsync(job.Url, analysisLogger, cancelTokenSrc.Token);
             var serviceWorkerAnalysisTask = serviceWorkerDetectionTask.ContinueWith(t => serviceWorkerAnalyzer.TryAnalyzeServiceWorkerAsync(t.Result, job.Url, analysisLogger, cancelTokenSrc.Token), TaskContinuationOptions.OnlyOnRanToCompletion).Unwrap(); // This will update analysis.Capabilities.
             var manifestDetectionTask = manifestDetector.TryDetectAsync(job.Url, analysisLogger, cancelTokenSrc.Token);
-            var manifestAnalysisTask = manifestDetectionTask.ContinueWith(t => manifestAnalyzer.TryAnalyzeManifestAsync(t.Result, PwaCapabilityCheckStatus.InProgress, logger, cancelTokenSrc.Token), TaskContinuationOptions.OnlyOnRanToCompletion).Unwrap();
+            var manifestAnalysisTask = manifestDetectionTask.ContinueWith(t => manifestAnalyzer.TryAnalyzeManifestAsync(t.Result, logger, cancelTokenSrc.Token), TaskContinuationOptions.OnlyOnRanToCompletion).Unwrap();
 
-            // Step 1: run the general capabilities, such as whether the URL serves HTML.
-            // We also use this to check if the URL serves HTML, and if not, to fail fast.
+            // Step 1: run the general capabilities, such as whether the URL serves HTML. If not, we fail fast.
             var generalCapabilities = await generalCapDetectionTask;
             analysis.ProcessCapabilities(generalCapabilities);
             var servesHtmlStatus = FailIfNotServedHtml(analysis, cancelTokenSrc);
@@ -159,23 +157,11 @@ private async Task TryProcessJobAsync(AnalysisJob job, CancellationToken cancelT
             analysis.ProcessCapabilities(swCapabilities);
             await db.SaveAsync(analysis);
 
-            // Step 6, run Lighthouse analysis. This is used for offline detection, HTTPS detection, and mixed content detection.
-            var lighthouseReport = await lighthouseAnalysisTask;
-            analysis.LighthouseReport = lighthouseReport;
-            analysis.ProcessLighthouseReport(lighthouseReport);
+            // Step 6, check for HTTPS.
+            var httpsCapabilities = TryCheckHttpsCapabilities(job.Url, analysis.WebManifest, analysis.ServiceWorker);
+            analysis.ProcessCapabilities(httpsCapabilities);
             await db.SaveAsync(analysis);
 
-            // Step 7, if we didn't find a manifest but Lighthouse found one,
-            // create a new ManifestDetection and rerun the manifest analyzer.
-            // This is needed for some edge cases where the manifest isn't picked up by our manifest detection service, but is picked up by Lighthouse. Example edge case: https://www.instagram.com/?utm_source=pwa_homescreen&__pwa=1
-            if (analysis.WebManifest == null)
-            {
-                analysis.WebManifest = manifestDetector.TryDetectFromLighthouse(lighthouseReport, analysisLogger);
-                var updatedManifestCapabilities = await manifestAnalyzer.TryAnalyzeManifestAsync(analysis.WebManifest, PwaCapabilityCheckStatus.Failed, analysisLogger, cancelTokenSrc.Token);
-                analysis.ProcessCapabilities(updatedManifestCapabilities);
-                await db.SaveAsync(analysis);
-            }            
-
             // All done! Mark the analysis as completed.
             analysis.Status = AnalysisStatus.Completed;
             analysis.Duration = DateTimeOffset.UtcNow.Subtract(analysis.CreatedAt);
@@ -211,16 +197,51 @@ private static PwaCapabilityCheckStatus FailIfNotServedHtml(Analysis analysis, C
         return servedHtmlCapability.Status;
     }
 
-    private async Task<LighthouseReport?> TryRunLighthouseAudit(AnalysisJob job, AnalysisLogger logger, CancellationToken cancelToken)
+    // private async Task<LighthouseReport?> TryRunLighthouseAudit(AnalysisJob job, AnalysisLogger logger, CancellationToken cancelToken)
+    // {
+    //     try
+    //     {
+    //         return await lighthouse.RunAuditAsync(job.Url, BrowserFormFactor.Desktop, logger, cancelToken);
+    //     }
+    //     catch (Exception error)
+    //     {
+    //         logger.LogError(error, "Error running Lighthouse audit for {url}", job.Url);
+    //         return null;
+    //     }
+    // }
+
+    private List<PwaCapability> TryCheckHttpsCapabilities(Uri url, ManifestDetection? manifestDetection, ServiceWorkerDetection? swDetection)
     {
+        var httpsCapabilities = PwaCapability.CreateHttpsCapabilities(); // There's only one HTTPS capability right now: has HTTPS
         try
         {
-            return await lighthouse.RunAuditAsync(job.Url, BrowserFormFactor.Desktop, logger, cancelToken);
+            var hasHttps = httpsCapabilities.First(c => c.Id == PwaCapabilityId.HasHttps);
+            if (url.Scheme != Uri.UriSchemeHttps)
+            {
+                // Mark as failed.
+                hasHttps.Status = PwaCapabilityCheckStatus.Failed;
+            }
+
+            // If we have a manifest, check if it has any HTTP URLs.
+            if (manifestDetection?.Url != null && manifestDetection.Url.Scheme != Uri.UriSchemeHttps)
+            {
+                hasHttps.Status = PwaCapabilityCheckStatus.Failed;
+            }
+
+            // If we have a service worker, check if it was served over HTTPS.
+            if (swDetection?.Url != null && swDetection.Url.Scheme != Uri.UriSchemeHttps)
+            {
+                hasHttps.Status = PwaCapabilityCheckStatus.Failed;
+            }
+
+            hasHttps.Status = PwaCapabilityCheckStatus.Passed;
+            return httpsCapabilities;
         }
-        catch (Exception error)
+        catch (Exception ex)
         {
-            logger.LogError(error, "Error running Lighthouse audit for {url}", job.Url);
-            return null;
+            logger.LogError(ex, "Error detecting HTTPS capabilities for {url}", url);
+            httpsCapabilities.ForEach(c => c.Status = PwaCapabilityCheckStatus.Skipped);
+            return httpsCapabilities;
         }
     }
 

apps/pwabuilder/Services/LighthouseService.cs

@@ -7,6 +7,7 @@
 
 namespace PWABuilder.Services;
 
+[Obsolete("LighthouseService shouldn't be used because Lighthouse 12 removed PWA audits. See https://github.com/GoogleChrome/lighthouse/blob/main/changelog.md#pwa-category-removal")]
 public class LighthouseService : ILighthouseService
 {
     private readonly IHostEnvironment env;
@@ -242,7 +243,7 @@ private static Process StartLighthouse(Uri url, BrowserFormFactor formFactor, in
             + $"--output=json --output-path=stdout "
             + $"--port={headlessChromePort} "
             + $"--config-path=\"{lighthouseSettingsPath}\" "
-            + $"--only-audits=installable-manifest,is-on-https,service-worker-audit,https-audit,offline-audit,web-app-manifest-raw-audit " 
+            + $"--only-audits=is-on-https " // Only check if the site is served over HTTPS
             + $"--form-factor={(formFactor == BrowserFormFactor.Desktop ? "desktop" : "mobile")} "
             + $"{(formFactor == BrowserFormFactor.Mobile ? "--screenEmulation.mobile " : string.Empty)}"
             + $"--screenEmulation.width={viewport.Width} "

apps/pwabuilder/Services/ManifestAnalyzer.cs

@@ -28,24 +28,23 @@ public ManifestAnalyzer(IImageValidationService imageValidator)
     /// Goes through all the manifest-specific capabilities of the specified <paramref name="analysis"/> and checks if the manifest passes.
     /// </summary>
     /// <param name="manifestDetection">The web app manifest detection results. This can be null if no web app manifest was detect.</param>
-    /// <param name="noManifestStatus">The status to assign to the "has manifest" capability if no manifest was detected.</param>
     /// <param name="cancelToken">The cancellation token.</param>
     /// <param name="logger">The logger to log data to.</param>
     /// <returns>A list of PWA capabilities and their statuses.</returns>
-    public async Task<List<PwaCapability>> TryAnalyzeManifestAsync(ManifestDetection? manifestDetection, PwaCapabilityCheckStatus noManifestStatus, ILogger logger, CancellationToken cancelToken)
+    public async Task<List<PwaCapability>> TryAnalyzeManifestAsync(ManifestDetection? manifestDetection, ILogger logger, CancellationToken cancelToken)
     {
         var manifestCapabilities = PwaCapability.CreateManifestCapabilities();
 
-        // No manifest? Mark all the manifest capabilities as skipped for now.
+        // No manifest? Mark all the manifest capabilities as skipped.
         if (manifestDetection == null)
         {
             logger.LogInformation("No manifest to analyze. Skipping manifest capability checks.");
 
-            // Mark the "manifest exists" capability with the desired status..
+            // Mark the "manifest exists" capability as failed.
             var manifestExistsCapability = manifestCapabilities.First(c => c.Id == PwaCapabilityId.HasManifest);
-            manifestExistsCapability.Status = noManifestStatus;
+            manifestExistsCapability.Status = PwaCapabilityCheckStatus.Failed;
 
-            // Mark all other manifest capabilities as skipped for now.
+            // Mark all other manifest capabilities as skipped.
             manifestCapabilities
                 .Except([manifestExistsCapability])
                 .ToList()
@@ -147,7 +146,6 @@ private PwaManifestCapabilityCheck CreateCheckForCapability(PwaCapability capabi
 
             // HTTPS capabilities are handled elsewhere.
             PwaCapabilityId.HasHttps => throw new NotImplementedException(),
-            PwaCapabilityId.NoMixedContent => throw new NotImplementedException(),
 
             // General capabilities are handled elsewhere.
             PwaCapabilityId.ServesHtml => throw new NotImplementedException()

apps/pwabuilder/Services/ManifestDetector.cs

@@ -42,43 +42,6 @@ public ManifestDetector(WebStringCache webStringCache, IPuppeteerService puppete
         return webManifest;
     }
 
-    /// <summary>
-    /// Inspects a LighthouseReport and sees if it's possible to generate a ManifestDetection from it.
-    /// </summary>
-    /// <param name="report">The Lighthouse report.</param>
-    /// <param name="logger">The logger.</param>
-    /// <returns>A <see cref="ManifestDetection"/> if the Lighthouse report found a valid manifest, otherwise null.</returns>
-    public ManifestDetection? TryDetectFromLighthouse(LighthouseReport? report, ILogger logger)
-    {
-        var manifestUrl = report?.WebAppManifestAudit?.Details?.ManifestUrl;
-        var manifestRaw = report?.WebAppManifestAudit?.Details?.ManifestRaw;
-        if (manifestUrl == null || manifestRaw == null || !Uri.TryCreate(manifestUrl, UriKind.Absolute, out var manifestUri))
-        {
-            return null;
-        }
-
-        JsonElement manifest;
-        try
-        {
-            manifest = JsonSerializer.Deserialize<JsonElement>(manifestRaw);
-        }
-        catch (Exception jsonParsingError)
-        {
-            logger.LogWarning(jsonParsingError, "Lighthouse report contained invalid JSON for the manifest at {manifestUrl}.", manifestUrl);
-            return null;
-        }
-
-        // Create a new ManifestDetection from the LighthouseReport
-        var webManifest = new ManifestDetection
-        {
-            Url = manifestUri,
-            ManifestRaw = manifestRaw,
-            Manifest = manifest
-        };
-
-        return webManifest;
-    }
-
     private async Task<ManifestDetection?> TryGetManifestFromPuppeteer(Uri appUrl, ILogger logger, CancellationToken cancelToken)
     {
         // Spin up a headless browser to find the manifest link.

apps/pwabuilder/Services/ServiceWorkerAnalyzer.cs

@@ -87,7 +87,7 @@ private PwaCapabilityCheckStatus RunCapabilityCheck(PwaCapability swCapability,
             return swCapability.Id switch
             {
                 PwaCapabilityId.HasServiceWorker => swDetection != null ? PwaCapabilityCheckStatus.Passed : PwaCapabilityCheckStatus.Failed,
-                PwaCapabilityId.OfflineSupport => PwaCapabilityCheckStatus.InProgress, // Offline support can't be detected from code analysis alone. Instead, we use Lighthouse for this. See LighthouseService.cs.
+                PwaCapabilityId.OfflineSupport => PwaCapabilityCheckStatus.Failed, // TODO: implement offline check. We used to test this using Lighthouse, but they removed offline audit check as of Lighthouse v12.
                 PwaCapabilityId.ServiceWorkerIsNotEmpty => CheckServiceWorkerNotEmpty(swScripts),
                 PwaCapabilityId.BackgroundSync => CheckBackgroundSync(swScripts),
                 PwaCapabilityId.PeriodicSync => CheckPeriodicSync(swScripts),