JPERF-729: Create a way to configure Jira admin user password during database setup

src/main/kotlin/com/atlassian/performance/tools/infrastructure/api/database/JiraUserPasswordOverridingDatabase.kt

@@ -41,11 +41,30 @@ class JiraUserPasswordOverridingDatabase internal constructor(
         if (userPassword == null) {
             logger.info("Password not provided, skipping dataset update")
         } else {
-            sqlClient.runSql(ssh, "UPDATE $cwdUserTableName SET credential='${userPassword.encrypted}' WHERE user_name='$username';")
+            if (shouldUseEncryption(ssh)) {
+                logger.info("Updating credential with encrypted password")
+                sqlClient.runSql(ssh, "UPDATE $cwdUserTableName SET credential='${userPassword.encrypted}' WHERE user_name='$username';")
+            } else {
+                logger.info("Updating credential with plain text password")
+                sqlClient.runSql(ssh, "UPDATE $cwdUserTableName SET credential='${userPassword.plainText}' WHERE user_name='$username';")
+            }
             logger.info("Password for user '$username' updated to '${userPassword.plainText}'")
         }
     }
 
+    private fun shouldUseEncryption(ssh: SshConnection): Boolean {
+        val dbNamePrefix = if (cwdUserTableName.contains(".")) cwdUserTableName.substringBefore(".") + "." else ""
+        val sqlResult = sqlClient.runSql(ssh, "select attribute_value from ${dbNamePrefix}cwd_directory_attribute where attribute_name = 'user_encryption_method';").output
+        return when  {
+            sqlResult.contains("plaintext") -> false
+            sqlResult.contains("atlassian-security") -> true
+            else -> {
+                logger.warn("Unknown user_encryption_method. Assuming encrypted password should be used")
+                true
+            }
+        }
+    }
+
     class Builder(
         private var databaseDelegate: Database,
         private var username: String,

src/test/kotlin/com/atlassian/performance/tools/infrastructure/api/database/JiraUserPasswordOverridingDatabaseTest.kt

@@ -1,8 +1,9 @@
 package com.atlassian.performance.tools.infrastructure.api.database
 
+import com.atlassian.performance.tools.infrastructure.mock.MockSshSqlClient
 import com.atlassian.performance.tools.infrastructure.mock.RememberingDatabase
 import com.atlassian.performance.tools.infrastructure.mock.RememberingSshConnection
-import com.atlassian.performance.tools.infrastructure.mock.RememberingSshSqlClient
+import com.atlassian.performance.tools.ssh.api.SshConnection
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
 import java.net.URI
@@ -52,11 +53,39 @@ class JiraUserPasswordOverridingDatabaseTest {
     }
 
     @Test
-    fun shouldExecuteUpdateOnCwdUserTable() {
+    fun shouldExecuteUpdateOnCwdUserTableWithEncryptedPassword_whenUnknownUserEncryptionMethod() {
+        // given
+        val cwdUserTableName = "jiradb.cwd_user"
+        val underlyingDatabase = RememberingDatabase()
+        val sqlClient = MockSshSqlClient()
+        val database = JiraUserPasswordOverridingDatabase(
+            databaseDelegate = underlyingDatabase,
+            sqlClient = sqlClient,
+            username = "admin",
+            userPassword = samplePassword,
+            cwdUserTableName = cwdUserTableName
+        )
+        val sshConnection = RememberingSshConnection()
+
+        // when
+        database.setup(sshConnection)
+        database.start(jira, sshConnection)
+
+        // then
+        assertThat(sqlClient.getLog())
+            .`as`("sql queries executed")
+            .containsExactly(
+                "select attribute_value from jiradb.cwd_directory_attribute where attribute_name = 'user_encryption_method';",
+                "UPDATE $cwdUserTableName SET credential='${samplePassword.encrypted}' WHERE user_name='admin';"
+            )
+    }
+
+    @Test
+    fun shouldExecuteUpdateOnCwdUserTableWithEncryptedPassword_whenAtlassianSecurityUserEncryptionMethod() {
         // given
         val cwdUserTableName = "cwd_user"
         val underlyingDatabase = RememberingDatabase()
-        val sqlClient = RememberingSshSqlClient()
+        val sqlClient = MockSshSqlClient()
         val database = JiraUserPasswordOverridingDatabase(
             databaseDelegate = underlyingDatabase,
             sqlClient = sqlClient,
@@ -65,14 +94,63 @@ class JiraUserPasswordOverridingDatabaseTest {
             cwdUserTableName = cwdUserTableName
         )
         val sshConnection = RememberingSshConnection()
+        sqlClient.queueReturnedSqlCommandResult(
+            SshConnection.SshResult(
+                exitStatus = 0,
+                output = """attribute_value
+                            atlassian-security
+""".trimMargin(),
+                errorOutput = ""
+            )
+        )
+
+        // when
+        database.setup(sshConnection)
+        database.start(jira, sshConnection)
+
+        // then
+        assertThat(sqlClient.getLog())
+            .`as`("sql queries executed")
+            .containsExactly(
+                "select attribute_value from cwd_directory_attribute where attribute_name = 'user_encryption_method';",
+                "UPDATE $cwdUserTableName SET credential='${samplePassword.encrypted}' WHERE user_name='admin';"
+            )
+    }
+
+    @Test
+    fun shouldExecuteUpdateOnCwdUserTableWithEncryptedPassword_whenPlainTextSecurityUserEncryptionMethod() {
+        // given
+        val cwdUserTableName = "cwd_user"
+        val underlyingDatabase = RememberingDatabase()
+        val sqlClient = MockSshSqlClient()
+        val database = JiraUserPasswordOverridingDatabase(
+            databaseDelegate = underlyingDatabase,
+            sqlClient = sqlClient,
+            username = "admin",
+            userPassword = samplePassword,
+            cwdUserTableName = cwdUserTableName
+        )
+        val sshConnection = RememberingSshConnection()
+        sqlClient.queueReturnedSqlCommandResult(
+            SshConnection.SshResult(
+                exitStatus = 0,
+                output = """attribute_value
+                            plaintext
+""".trimMargin(),
+                errorOutput = ""
+            )
+        )
 
         // when
         database.setup(sshConnection)
         database.start(jira, sshConnection)
 
         // then
         assertThat(sqlClient.getLog())
-            .`as`("sql command executed")
-            .contains("UPDATE $cwdUserTableName SET credential='${samplePassword.encrypted}' WHERE user_name='admin';")
+            .`as`("sql queries executed")
+            .containsExactly(
+                "select attribute_value from cwd_directory_attribute where attribute_name = 'user_encryption_method';",
+                "UPDATE $cwdUserTableName SET credential='${samplePassword.plainText}' WHERE user_name='admin';"
+            )
     }
 }

src/test/kotlin/com/atlassian/performance/tools/infrastructure/mock/MockSshSqlClient.kt

@@ -0,0 +1,34 @@
+package com.atlassian.performance.tools.infrastructure.mock
+
+import com.atlassian.performance.tools.infrastructure.database.SshSqlClient
+import com.atlassian.performance.tools.ssh.api.SshConnection
+import java.io.File
+import java.util.*
+
+class MockSshSqlClient : SshSqlClient {
+    private val log = mutableListOf<String>()
+    private val defaultSshResult = SshConnection.SshResult(
+        exitStatus = 0,
+        output = "",
+        errorOutput = ""
+    )
+    private val returnedCommandResults = ArrayDeque<SshConnection.SshResult>()
+
+    fun queueReturnedSqlCommandResult(result: SshConnection.SshResult) {
+        returnedCommandResults.add(result)
+    }
+
+    override fun runSql(
+        ssh: SshConnection,
+        sql: String
+    ) = (if (returnedCommandResults.isEmpty()) defaultSshResult else returnedCommandResults.pop())
+        .also { log.add(sql) }
+
+    override fun runSql(
+        ssh: SshConnection,
+        sql: File
+    ) = (if (returnedCommandResults.isEmpty()) defaultSshResult else returnedCommandResults.pop())
+        .also { log.add(sql.readText()) }
+
+    fun getLog(): List<String> = log
+}