only run test for moonbitlang project

src/dashboard.rs

@@ -48,12 +48,17 @@ pub enum MoonCommand {
 }
 
 impl MoonCommand {
-    pub fn args(&self) -> Vec<&str> {
+    pub fn args(&self, is_moonbit_community: bool) -> Vec<&str> {
         match self {
             MoonCommand::Check(backend) => vec!["check", "-q", "--target", backend.to_flag()],
             MoonCommand::Build(backend) => vec!["build", "-q", "--target", backend.to_flag()],
             MoonCommand::Test(backend) => {
-                vec!["test", "-q", "--target", backend.to_flag()]
+                // only run test for moonbit community project
+                if is_moonbit_community {
+                    vec!["test", "-q", "--target", backend.to_flag()]
+                } else {
+                    vec!["test", "-q", "--build-only", "--target", backend.to_flag()]
+                }
             }
         }
     }

src/main.rs

@@ -200,7 +200,12 @@ fn stat_mooncake(
 ) -> Result<ExecuteResult, StatMooncakeError> {
     let _ = run_moon(workdir, source, &["clean"]);
 
-    let r = run_moon(workdir, source, &cmd.args()).map_err(|e| StatMooncakeError::RunMoon(e));
+    let is_moonbit_community = match source {
+        MooncakeSource::MooncakesIO { name, .. } => name.contains("moonbitlang"),
+        MooncakeSource::Git { url, .. } => url.contains("moonbitlang") || url.contains("moonbit-community"),
+    };
+
+    let r = run_moon(workdir, source, &cmd.args(is_moonbit_community)).map_err(|e| StatMooncakeError::RunMoon(e));
     let status = match r.as_ref() {
         Ok(output) if output.success => Status::Success,
         _ => Status::Failure,

webapp/src/App.tsx

@@ -438,7 +438,7 @@ const App = () => {
           const bleedingSuccess = bleedingEntry.cbts.some(cbt => checkItemStatus(cbt, phase, backend));
 
           if (stableSuccess && !bleedingSuccess) {
-            return `Regression detected: ${platform}'s ${backend} ${phase} passed in stable but failed in bleeding-edge`;
+            return `Regression detected: ${backend} ${phase} passed in stable but failed in bleeding`;
           }
         }
       }
@@ -472,8 +472,7 @@ const App = () => {
         const failurePlatforms = Array.from(results.entries()).filter(([_, success]) => !success).map(([platform]) => platform);
 
         if (successPlatforms.length > 0 && failurePlatforms.length > 0) {
-          const version = useBleedingEdge ? "bleeding-edge" : "stable";
-          return `Platform inconsistency in ${version}: ${backend} ${phase} passed on ${successPlatforms.join(', ')} but failed on ${failurePlatforms.join(', ')}`;
+          return `Platform inconsistency: ${backend} ${phase} passed on ${successPlatforms.join(', ')} but failed on ${failurePlatforms.join(', ')}`;
         }
       }
     }
@@ -505,8 +504,7 @@ const App = () => {
         const failureBackends = backendResults.filter(r => !r.success).map(r => r.backend);
 
         if (successBackends.length > 0 && failureBackends.length > 0) {
-          const version = useBleedingEdge ? "bleeding-edge" : "stable";
-          return `Backend inconsistency in ${version} on ${platform}: ${phase} passed on ${successBackends.join(', ')} but failed on ${failureBackends.join(', ')}`;
+          return `Backend inconsistency: ${phase} passed on ${successBackends.join(', ')} but failed on ${failureBackends.join(', ')}`;
         }
       }
     }
@@ -538,8 +536,7 @@ const App = () => {
         const failurePhases = phaseResults.filter(r => !r.success).map(r => r.phase);
 
         if (successPhases.length > 0 && failurePhases.length > 0) {
-          const version = useBleedingEdge ? "bleeding-edge" : "stable";
-          return `Phase inconsistency in ${version} on ${platform}'s ${backend}: passed ${successPhases.join(', ')} but failed ${failurePhases.join(', ')}`;
+          return `Phase inconsistency: passed ${successPhases.join(', ')} but failed ${failurePhases.join(', ')}`;
         }
       }
     }
@@ -553,7 +550,7 @@ const App = () => {
     const bleedingSuccess = isAllSuccess(index, data, true);
 
     if (stableSuccess && bleedingSuccess) {
-      return { text: "All tests passed in both stable and bleeding-edge on all platforms", status: 'success' };
+      return { text: "All passed", status: 'success' };
     }
 
     // 按优先级检查各种差异