NIT Refactor SipScalaTests

- fix confusing 'restricted mode' naming in favor of `power mode`
- misc fixes

Author: Gedochao

modules/integration/src/test/scala/scala/cli/integration/SipScalaTests.scala

@@ -16,16 +16,16 @@ class SipScalaTests extends ScalaCliSuite {
       newCliPath
     }
   }
-  def powerArgs(isRestricted: Boolean) = if (isRestricted) Nil else Seq("--power")
+  def powerArgs(isPowerMode: Boolean): Seq[String] = if (isPowerMode) Seq("--power") else Nil
 
-  def testDirectoriesCommand(isRestricted: Boolean): Unit =
+  def testDirectoriesCommand(isPowerMode: Boolean): Unit =
     TestInputs.empty.fromRoot { root =>
-      val res = os.proc(TestUtil.cli, powerArgs(isRestricted), "directories").call(
+      val res = os.proc(TestUtil.cli, powerArgs(isPowerMode), "directories").call(
         cwd = root,
         check = false,
         mergeErrIntoOut = true
       )
-      if (isRestricted) {
+      if (!isPowerMode) {
         expect(res.exitCode == 1)
         val output = res.out.text()
         expect(output.contains(
@@ -35,7 +35,7 @@ class SipScalaTests extends ScalaCliSuite {
       else expect(res.exitCode == 0)
     }
 
-  def testPublishDirectives(isRestricted: Boolean): Unit = TestInputs.empty.fromRoot { root =>
+  def testPublishDirectives(isPowerMode: Boolean): Unit = TestInputs.empty.fromRoot { root =>
     val code =
       """
         | //> using publish.name "my-library"
@@ -45,13 +45,13 @@ class SipScalaTests extends ScalaCliSuite {
     val source = root / "A.scala"
     os.write(source, code)
 
-    val res = os.proc(TestUtil.cli, powerArgs(isRestricted), "compile", source).call(
+    val res = os.proc(TestUtil.cli, powerArgs(isPowerMode), "compile", source).call(
       cwd = root,
       check = false,
       mergeErrIntoOut = true
     )
 
-    if (isRestricted) {
+    if (!isPowerMode) {
       expect(res.exitCode == 1)
       val output = res.out.text()
       expect(output.contains(s"directive is experimental"))
@@ -60,7 +60,7 @@ class SipScalaTests extends ScalaCliSuite {
       expect(res.exitCode == 0)
   }
 
-  def testMarkdownOptions(isRestricted: Boolean): Unit = TestInputs.empty.fromRoot { root =>
+  def testMarkdownOptions(isPowerMode: Boolean): Unit = TestInputs.empty.fromRoot { root =>
     val code =
       """
         | println("ala")
@@ -70,12 +70,12 @@ class SipScalaTests extends ScalaCliSuite {
     os.write(source, code)
 
     val res =
-      os.proc(TestUtil.cli, powerArgs(isRestricted), "--scala", "3", "--markdown", source).call(
+      os.proc(TestUtil.cli, powerArgs(isPowerMode), "--scala", "3", "--markdown", source).call(
         cwd = root,
         check = false,
         mergeErrIntoOut = true
       )
-    if (isRestricted) {
+    if (!isPowerMode) {
       expect(res.exitCode == 1)
       val output = res.out.text()
       expect(output.contains(s"option is experimental"))
@@ -97,42 +97,45 @@ class SipScalaTests extends ScalaCliSuite {
       }
     }
 
-  def testDefaultHelpOutput(isRestricted: Boolean): Unit = TestInputs.empty.fromRoot { root =>
+  def testDefaultHelpOutput(isPowerMode: Boolean): Unit = TestInputs.empty.fromRoot { root =>
     for (helpOptions <- HelpTests.variants) {
       val output =
-        os.proc(TestUtil.cli, powerArgs(isRestricted), helpOptions).call(cwd = root).out.trim()
+        os.proc(TestUtil.cli, powerArgs(isPowerMode), helpOptions).call(cwd = root).out.trim()
       val restrictedFeaturesMentioned = output.contains("package")
-      if (isRestricted) expect(!restrictedFeaturesMentioned)
+      if (!isPowerMode) expect(!restrictedFeaturesMentioned)
       else expect(restrictedFeaturesMentioned)
     }
   }
 
-  def testReplHelpOutput(isRestricted: Boolean): Unit = TestInputs.empty.fromRoot { root =>
+  def testReplHelpOutput(isPowerMode: Boolean): Unit = TestInputs.empty.fromRoot { root =>
     val output =
-      os.proc(TestUtil.cli, powerArgs(isRestricted), "repl", "--help-full").call(cwd =
+      os.proc(TestUtil.cli, powerArgs(isPowerMode), "repl", "--help-full").call(cwd =
         root
       ).out.trim()
     val restrictedFeaturesMentioned   = output.contains("--amm")
     val experimentalFeaturesMentioned = output.contains("--python")
-    if (isRestricted) expect(!restrictedFeaturesMentioned && !experimentalFeaturesMentioned)
+    if (!isPowerMode) expect(!restrictedFeaturesMentioned && !experimentalFeaturesMentioned)
     else expect(restrictedFeaturesMentioned && experimentalFeaturesMentioned)
   }
 
-  for (isRestricted <- Seq(false, true)) {
-    test(s"test directories command when restricted mode is enabled: $isRestricted") {
-      testDirectoriesCommand(isRestricted)
+  for {
+    isPowerMode <- Seq(false, true)
+    powerModeString = if (isPowerMode) "enabled" else "disabled"
+  } {
+    test(s"test directories command when power mode is $powerModeString") {
+      testDirectoriesCommand(isPowerMode)
     }
-    test(s"test publish directives when restricted mode is enabled: $isRestricted") {
-      testPublishDirectives(isRestricted)
+    test(s"test publish directives when power mode is $powerModeString") {
+      testPublishDirectives(isPowerMode)
     }
-    test(s"test markdown options when restricted mode is enabled: $isRestricted") {
-      testMarkdownOptions(isRestricted)
+    test(s"test markdown options when power mode is $powerModeString") {
+      testMarkdownOptions(isPowerMode)
     }
-    test(s"test default help when restricted mode is enabled: $isRestricted") {
-      testDefaultHelpOutput(isRestricted)
+    test(s"test default help when power mode is $powerModeString") {
+      testDefaultHelpOutput(isPowerMode)
     }
-    test(s"test repl help when restricted mode is enabled: $isRestricted") {
-      testReplHelpOutput(isRestricted)
+    test(s"test repl help when power mode is $powerModeString") {
+      testReplHelpOutput(isPowerMode)
     }
   }