Add E2E test for gateway connect (#3577)

Author: rli

buildspec/linuxIntegrationTests.yml

@@ -24,6 +24,8 @@ phases:
       - export PATH="${PATH}:${DOTNET_ROOT}"
       - export PATH="$PATH:$HOME/.dotnet/tools"
       - dotnet codeartifact-creds install
+      # should probably be managed as an extension/rule in any tests that need a screen available
+      - /usr/bin/Xvfb :22 -screen 0 1920x1080x24 &
 
   build:
     commands:
@@ -41,7 +43,7 @@ phases:
         credential_source=EcsContainer"
 
       - chmod +x gradlew
-      - ./gradlew -PideProfileName=$ALTERNATIVE_IDE_PROFILE_NAME integrationTest coverageReport --info --console plain
+      - DISPLAY=:22 ./gradlew -PideProfileName=$ALTERNATIVE_IDE_PROFILE_NAME integrationTest coverageReport --info --console plain
       - |
         if [ $(docker ps -q | wc -l) -gt 0 ]; then
             echo 'Docker containers were not completely cleaned up!';

jetbrains-core/detekt-baseline-test.xml

@@ -135,7 +135,6 @@
     <ID>UseCheckOrError:JavaTestUtils.kt$throw IllegalStateException("Failed to locate gradlew")</ID>
     <ID>UseCheckOrError:MockClientManager.kt$MockClientManager$throw IllegalStateException("No mock registered for $sdkClass")</ID>
     <ID>UseCheckOrError:MockRegionProvider.kt$MockRegionProviderRule$throw IllegalStateException("Failed to generate a unique region ID")</ID>
-    <ID>UseCheckOrError:MockToolManager.kt$MockToolManager$throw IllegalStateException("Must register ManagedToolType via a MockMockToolManagerRule before using it in a test")</ID>
     <ID>UseCheckOrError:RunWithRealCredentials.kt$RunWithRealCredentials.&lt;no name provided>$throw IllegalStateException("Can't locate us-west-2")</ID>
     <ID>UseCheckOrError:RunWithRealCredentials.kt$RunWithRealCredentials.&lt;no name provided>$throw IllegalStateException("RunWithRealCredentials requires a default AWS profile!")</ID>
     <ID>UseOrEmpty:EditAttributesDialogTest.kt$EditAttributesDialogTest$testMessageSize?.toString() ?: ""</ID>

jetbrains-core/detekt-baseline.xml

@@ -166,7 +166,6 @@
     <ID>UseCheckOrError:LocalLambdaRunSettings.kt$throw IllegalStateException("Can't find debugger support for $this")</ID>
     <ID>UseCheckOrError:MockClientManager.kt$MockClientManager$throw IllegalStateException("No mock registered for $sdkClass")</ID>
     <ID>UseCheckOrError:MockRegionProvider.kt$MockRegionProviderRule$throw IllegalStateException("Failed to generate a unique region ID")</ID>
-    <ID>UseCheckOrError:MockToolManager.kt$MockToolManager$throw IllegalStateException("Must register ManagedToolType via a MockMockToolManagerRule before using it in a test")</ID>
     <ID>UseCheckOrError:OpenShellInContainerDialog.kt$OpenShellInContainerDialog$throw IllegalStateException("Task not Selected")</ID>
     <ID>UseCheckOrError:ProfileCredentialProviderFactory.kt$ProfileCredentialProviderFactory$throw IllegalStateException("Profile $sourceProfileName looks to have been removed")</ID>
     <ID>UseCheckOrError:ProfileCredentialProviderFactory.kt$ProfileCredentialProviderFactory$throw IllegalStateException("Profile ${profileProviderId.profileName} looks to have been removed")</ID>

jetbrains-core/src-222+/software/aws/toolkits/jetbrains/services/caws/CawsParameterDescriptions.kt

@@ -44,21 +44,19 @@ data class Ram(
 )
 
 fun isSubscriptionFreeTier(
-    existingProject: CawsProject?,
     client: CodeCatalystClient,
     space: String?
 ): Boolean {
     val subscriptionTier = if (space != null) {
-        checkIfSubscriptionIsFreeTier(client, space)
+        client.getSubscription {
+            it.spaceName(space)
+        }.subscriptionType()
     } else {
         return true
     }
 
     return subscriptionTier == "FREE"
 }
-fun checkIfSubscriptionIsFreeTier(client: CodeCatalystClient, org: String): String = client.getSubscription {
-    it.spaceName(org)
-}.subscriptionType()
 
 fun InstanceType.isSupportedInFreeTier() =
     when (this) {

jetbrains-core/src/software/aws/toolkits/jetbrains/AwsToolkit.kt

@@ -4,9 +4,11 @@
 package software.aws.toolkits.jetbrains
 
 import com.intellij.ide.plugins.PluginManagerCore
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.extensions.PluginDescriptor
 import com.intellij.openapi.extensions.PluginId
 import com.intellij.openapi.util.registry.Registry
+import java.nio.file.Paths
 
 object AwsToolkit {
     const val PLUGIN_ID = "aws.toolkit"
@@ -21,7 +23,11 @@ object AwsToolkit {
         PluginManagerCore.getPlugin(PluginId.getId(PLUGIN_ID))
     }
 
-    fun pluginPath() = DESCRIPTOR?.pluginPath ?: throw RuntimeException("Toolkit root not available")
+    fun pluginPath() = if (ApplicationManager.getApplication().isUnitTestMode) {
+        Paths.get(System.getProperty("plugin.path"))
+    } else {
+        DESCRIPTOR?.pluginPath ?: throw RuntimeException("Toolkit root not available")
+    }
 
     fun isDeveloperMode() = Registry.`is`("aws.toolkit.developerMode", false)
 }

jetbrains-core/tst/software/aws/toolkits/jetbrains/core/credentials/sso/MockSsoLoginCallbackProvider.kt

@@ -18,22 +18,32 @@ import software.aws.toolkits.jetbrains.utils.scrubException
 
 internal class MockSsoLoginCallbackProvider : SsoLoginCallbackProvider {
     internal var provider: SsoLoginCallback? = null
-    private object NoOpSsoLoginCallback : SsoLoginCallback {
-        override fun tokenPending(authorization: Authorization) {}
+    private object ErrorSsoLoginCallback : SsoLoginCallback {
+        override fun tokenPending(authorization: Authorization) {
+            error("Not implemented")
+        }
 
         override fun tokenRetrieved() {}
 
         override fun tokenRetrievalFailure(e: Exception) {}
     }
 
     override fun getProvider(ssoUrl: String): SsoLoginCallback =
-        provider ?: NoOpSsoLoginCallback
+        provider ?: ErrorSsoLoginCallback
 
     companion object {
         fun getInstance() = service<SsoLoginCallbackProvider>() as MockSsoLoginCallbackProvider
     }
 }
 
+object NoOpSsoLoginCallback : SsoLoginCallback {
+    override fun tokenPending(authorization: Authorization) {}
+
+    override fun tokenRetrieved() {}
+
+    override fun tokenRetrievalFailure(e: Exception) {}
+}
+
 internal class TestSsoPrompt(private val secretName: String) : SsoLoginCallback {
     override fun tokenPending(authorization: Authorization) {
         val authLambda = System.getenv(authLambdaArn)

jetbrains-core/tst/software/aws/toolkits/jetbrains/core/credentials/sso/SsoAccessTokenProviderTest.kt

@@ -4,6 +4,7 @@
 package software.aws.toolkits.jetbrains.core.credentials.sso
 
 import com.intellij.testFramework.ApplicationRule
+import com.intellij.testFramework.RuleChain
 import kotlinx.coroutines.runBlocking
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
@@ -32,6 +33,7 @@ import software.amazon.awssdk.services.ssooidc.model.StartDeviceAuthorizationRes
 import software.aws.toolkits.core.region.aRegionId
 import software.aws.toolkits.core.utils.delegateMock
 import software.aws.toolkits.core.utils.test.aString
+import software.aws.toolkits.jetbrains.utils.rules.SsoLoginCallbackProviderRule
 import java.time.Clock
 import java.time.Duration
 import java.time.Instant
@@ -50,9 +52,12 @@ class SsoAccessTokenProviderTest {
     private lateinit var sut: SsoAccessTokenProvider
     private lateinit var ssoCache: SsoCache
 
+    private val applicationRule = ApplicationRule()
+    private val ssoCallbackRule = SsoLoginCallbackProviderRule()
+
     @JvmField
     @Rule
-    val applicationRule = ApplicationRule()
+    val ruleChain = RuleChain(applicationRule, ssoCallbackRule)
 
     @Before
     fun setUp() {

jetbrains-core/tst/software/aws/toolkits/jetbrains/core/tools/MockToolManager.kt

@@ -3,9 +3,12 @@
 
 package software.aws.toolkits.jetbrains.core.tools
 
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import com.intellij.testFramework.ApplicationRule
+import com.intellij.testFramework.replaceService
 import java.nio.file.Path
 
 @Suppress("UNCHECKED_CAST")
@@ -16,7 +19,7 @@ internal class MockToolManager : ToolManager {
     override fun <V : Version> getTool(type: ToolType<V>): Tool<ToolType<V>>? = tools[type]?.let { it as Tool<ToolType<V>> }
 
     override fun <V : Version> getOrInstallTool(type: ManagedToolType<V>, project: Project?): Tool<ToolType<V>> =
-        getTool(type) ?: throw IllegalStateException("Must register ManagedToolType via a MockMockToolManagerRule before using it in a test")
+        getTool(type) ?: error("Must register ManagedToolType via a MockToolManagerRule before using it in a test")
 
     override fun <V : Version> getToolForPath(type: ToolType<V>, toolExecutablePath: Path): Tool<ToolType<V>> {
         TODO("Not yet implemented")
@@ -42,4 +45,11 @@ class MockToolManagerRule : ApplicationRule() {
     override fun after() {
         getMockInstance().tools.clear()
     }
+
+    companion object {
+        fun useRealTools(disposable: Disposable) {
+            val toolManager = DefaultToolManager()
+            ApplicationManager.getApplication().replaceService(ToolManager::class.java, toolManager, disposable)
+        }
+    }
 }

jetbrains-ultimate/it/software/aws/toolkits/jetbrains/utils/UltimateTestUtils.kt renamed to jetbrains-core/tst/software/aws/toolkits/jetbrains/utils/FrameworkTestUtils.kt

@@ -1,16 +1,16 @@
-// Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
 package software.aws.toolkits.jetbrains.utils
 
 import org.jetbrains.ide.BuiltInServerManager
 import java.util.concurrent.atomic.AtomicReference
 
-object UltimateTestUtils {
+object FrameworkTestUtils {
     private val serverStarted = AtomicReference(false)
 
-    // Make sure the built in sever is started. This is not done in unit test mode, so it must be done
-    // for several integration tests
+    // Make sure the built in server is started. This is not done in unit test mode, so it must be done
+    // for several integration tests in ultimate/gateway
     fun ensureBuiltInServerStarted() {
         serverStarted.getAndUpdate { started ->
             if (!started) {

jetbrains-core/tst/software/aws/toolkits/jetbrains/utils/extensions/DevEnvironmentExtension.kt

@@ -0,0 +1,49 @@
+// Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.utils.extensions
+
+import org.junit.jupiter.api.extension.AfterAllCallback
+import org.junit.jupiter.api.extension.ExtensionContext
+import software.amazon.awssdk.services.codecatalyst.CodeCatalystClient
+import software.amazon.awssdk.services.codecatalyst.model.CreateDevEnvironmentRequest
+import software.aws.toolkits.jetbrains.core.AwsClientManager
+import software.aws.toolkits.jetbrains.core.credentials.ToolkitConnection
+
+class DevEnvironmentExtension(
+    connection: () -> ToolkitConnection,
+    environmentBuilder: (CodeCatalystClient, CreateDevEnvironmentRequest.Builder) -> Unit
+) : AfterAllCallback {
+    private val client: CodeCatalystClient by lazy {
+        AwsClientManager.getInstance().getClient(connection().getConnectionSettings())
+    }
+
+    private val lazyEnvironment = lazy {
+        client.createDevEnvironment {
+            environmentBuilder(client, it)
+        }.let {
+            DevEnvironment(
+                spaceName = it.spaceName(),
+                projectName = it.projectName(),
+                id = it.id()
+            )
+        }
+    }
+    val environment: DevEnvironment by lazyEnvironment
+
+    override fun afterAll(context: ExtensionContext) {
+        if (lazyEnvironment.isInitialized()) {
+            client.deleteDevEnvironment {
+                it.spaceName(environment.spaceName)
+                it.projectName(environment.projectName)
+                it.id(environment.id)
+            }
+        }
+    }
+}
+
+data class DevEnvironment(
+    val spaceName: String,
+    val projectName: String,
+    val id: String
+)