Remove the BaseState system from run configs

.changes/next-release/bugfix-04244d8a-3206-4b6f-97d8-15f82bdeeb53.json

@@ -0,0 +1,4 @@
+{
+  "type" : "bugfix",
+  "description" : "Fix issue where modifying a cloned run config results in mutation of the original"
+}

jetbrains-core/it/software/aws/toolkits/jetbrains/services/lambda/execution/local/LocalLambdaRunConfigurationTest.kt

@@ -165,6 +165,22 @@ class LocalLambdaRunConfigurationTest {
         }
     }
 
+    @Test
+    fun templateFileDoesNotExist() {
+        runInEdtAndWait {
+            val runConfiguration = createTemplateRunConfiguration(
+                project = projectRule.project,
+                templateFile = "IAmFake",
+                logicalId = "Function",
+                credentialsProviderId = mockId
+            )
+            assertThat(runConfiguration).isNotNull
+            assertThatThrownBy { runConfiguration.checkConfiguration() }
+                .isInstanceOf(RuntimeConfigurationError::class.java)
+                .hasMessage(message("lambda.run_configuration.sam.template_file_not_found"))
+        }
+    }
+
     @Test
     fun functionDoesNotExist() {
         runInEdtAndWait {
@@ -629,6 +645,24 @@ class LocalLambdaRunConfigurationTest {
         }
     }
 
+    @Test // https://github.com/aws/aws-toolkit-jetbrains/issues/1072
+    fun creatingACopyDoesNotAliasFields() {
+        runInEdtAndWait {
+            val runConfiguration = createHandlerBasedRunConfiguration(
+                project = projectRule.project,
+                credentialsProviderId = mockId,
+                input = "{}"
+            )
+
+            val clonedConfiguration = runConfiguration.clone() as LocalLambdaRunConfiguration
+            clonedConfiguration.name = "Cloned"
+
+            clonedConfiguration.useInputText("Changed input")
+
+            assertThat(clonedConfiguration.inputSource()).isNotEqualTo(runConfiguration.inputSource())
+        }
+    }
+
     private fun getState(runConfiguration: LocalLambdaRunConfiguration): SamRunningState {
         val executor = ExecutorRegistry.getInstance().getExecutorById(DefaultRunExecutor.EXECUTOR_ID)
         val environmentMock = mock<ExecutionEnvironment> {

jetbrains-core/src/software/aws/toolkits/jetbrains/services/lambda/execution/LambdaRunConfigurationBase.kt

@@ -5,16 +5,17 @@ package software.aws.toolkits.jetbrains.services.lambda.execution
 
 import com.intellij.execution.configurations.ConfigurationFactory
 import com.intellij.execution.configurations.LocatableConfigurationBase
-import com.intellij.execution.configurations.LocatableRunConfigurationOptions
+import com.intellij.execution.configurations.RunConfiguration
 import com.intellij.execution.configurations.RunConfigurationWithSuppressedDefaultDebugAction
 import com.intellij.execution.configurations.RuntimeConfigurationError
 import com.intellij.execution.runners.RunConfigurationWithSuppressedDefaultRunAction
-import com.intellij.openapi.components.BaseState
 import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.vfs.LocalFileSystem
+import com.intellij.util.xmlb.XmlSerializer
 import com.intellij.util.xmlb.annotations.Property
+import org.jdom.Element
 import software.aws.toolkits.core.credentials.CredentialProviderNotFound
 import software.aws.toolkits.jetbrains.core.credentials.CredentialManager
 import software.aws.toolkits.jetbrains.core.region.AwsRegionProvider
@@ -23,29 +24,51 @@ import java.nio.charset.StandardCharsets
 
 abstract class LambdaRunConfigurationBase<T : BaseLambdaOptions>(
     project: Project,
-    factory: ConfigurationFactory,
+    private val configFactory: ConfigurationFactory,
     id: String
-) : LocatableConfigurationBase<T>(project, factory, id),
+) : LocatableConfigurationBase<T>(project, configFactory, id),
     RunConfigurationWithSuppressedDefaultRunAction,
     RunConfigurationWithSuppressedDefaultDebugAction {
 
-    override fun getOptions() = super.getOptions() as BaseLambdaOptions
+    protected abstract val state: BaseLambdaOptions
+
+    final override fun readExternal(element: Element) {
+        super.readExternal(element)
+        XmlSerializer.deserializeInto(state, element)
+    }
+
+    final override fun writeExternal(element: Element) {
+        super.writeExternal(element)
+        XmlSerializer.serializeInto(state, element)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    final override fun clone(): RunConfiguration {
+        val element = Element("toClone")
+        writeExternal(element)
+
+        val copy = configFactory.createTemplateConfiguration(project) as LambdaRunConfigurationBase<*>
+        copy.name = name
+        copy.readExternal(element)
+
+        return copy
+    }
 
     fun useInputFile(inputFile: String?) {
-        val inputOptions = options.inputOptions
+        val inputOptions = state.inputOptions
         inputOptions.inputIsFile = true
         inputOptions.input = inputFile
     }
 
     fun useInputText(input: String?) {
-        val inputOptions = options.inputOptions
+        val inputOptions = state.inputOptions
         inputOptions.inputIsFile = false
         inputOptions.input = input
     }
 
-    fun isUsingInputFile() = options.inputOptions.inputIsFile
+    fun isUsingInputFile() = state.inputOptions.inputIsFile
 
-    fun inputSource() = options.inputOptions.input
+    fun inputSource() = state.inputOptions.input
 
     protected fun checkInput() {
         inputSource()?.let {
@@ -77,10 +100,10 @@ abstract class LambdaRunConfigurationBase<T : BaseLambdaOptions>(
         }
     } ?: throw RuntimeConfigurationError(message("lambda.run_configuration.no_input_specified"))
 
-    fun credentialProviderId() = options.accountOptions.credentialProviderId
+    fun credentialProviderId() = state.accountOptions.credentialProviderId
 
     fun credentialProviderId(credentialsProviderId: String?) {
-        options.accountOptions.credentialProviderId = credentialsProviderId
+        state.accountOptions.credentialProviderId = credentialsProviderId
     }
 
     protected fun resolveCredentials() = credentialProviderId()?.let {
@@ -98,30 +121,30 @@ abstract class LambdaRunConfigurationBase<T : BaseLambdaOptions>(
         }
     } ?: throw RuntimeConfigurationError(message("lambda.run_configuration.no_credentials_specified"))
 
-    fun regionId() = options.accountOptions.regionId
+    fun regionId() = state.accountOptions.regionId
 
     fun regionId(regionId: String?) {
-        options.accountOptions.regionId = regionId
+        state.accountOptions.regionId = regionId
     }
 
     protected fun resolveRegion() = regionId()?.let {
         AwsRegionProvider.getInstance().regions()[it]
     } ?: throw RuntimeConfigurationError(message("lambda.run_configuration.no_region_specified"))
 }
 
-open class BaseLambdaOptions : LocatableRunConfigurationOptions() {
+open class BaseLambdaOptions {
     @get:Property(flat = true) // flat for backwards compat
-    var accountOptions by property(AccountOptions())
+    var accountOptions = AccountOptions()
     @get:Property(flat = true) // flat for backwards compat
-    var inputOptions by property(InputOptions())
+    var inputOptions = InputOptions()
 }
 
-class AccountOptions : BaseState() {
-    var credentialProviderId by property("")
-    var regionId by property("")
+class AccountOptions {
+    var credentialProviderId: String? = null
+    var regionId: String? = null
 }
 
-class InputOptions : BaseState() {
-    var inputIsFile by property(false)
-    var input by string()
+class InputOptions {
+    var inputIsFile = false
+    var input: String? = null
 }

jetbrains-core/src/software/aws/toolkits/jetbrains/services/lambda/execution/local/LocalLambdaOptions.kt

@@ -3,26 +3,27 @@
 
 package software.aws.toolkits.jetbrains.services.lambda.execution.local
 
-import com.intellij.openapi.components.BaseState
 import com.intellij.util.xmlb.annotations.OptionTag
 import com.intellij.util.xmlb.annotations.Property
+import com.intellij.util.xmlb.annotations.Tag
 import software.aws.toolkits.jetbrains.services.lambda.execution.BaseLambdaOptions
 import software.aws.toolkits.jetbrains.services.lambda.sam.SamOptions
-import java.util.LinkedHashMap
 
+@Tag("LocalLambdaOptions")
 class LocalLambdaOptions : BaseLambdaOptions() {
     @get:Property(flat = true) // flat for backwards compat
-    var functionOptions by property(FunctionOptions())
+    var functionOptions = FunctionOptions()
     @get:Property(surroundWithTag = false)
-    var samOptions by property(SamOptions())
+    var samOptions = SamOptions()
 }
 
-class FunctionOptions : BaseState() {
-    var useTemplate by property(false)
-    var templateFile by string()
+@Tag("FunctionOptions")
+class FunctionOptions {
+    var useTemplate = false
+    var templateFile: String? = null
     @get:OptionTag("logicalFunctionName")
-    var logicalId by string()
-    var runtime by string()
-    var handler by string()
-    var environmentVariables by map(LinkedHashMap<String, String>())
+    var logicalId: String? = null
+    var runtime: String? = null
+    var handler: String? = null
+    var environmentVariables: Map<String, String> = linkedMapOf<String, String>()
 }