more test cases

kyuubi-common/src/main/scala/org/apache/kyuubi/service/authentication/JdbcAuthenticationProviderImpl.scala

@@ -111,19 +111,24 @@ class JdbcAuthenticationProviderImpl(conf: KyuubiConf) extends PasswdAuthenticat
     debug(configLog("Query SQL", querySql.orNull))
 
     // Check if JDBC parameters valid
-    if (dbDriver.isEmpty || dbUrl.isEmpty || dbUserName.isEmpty || dbPassword.isEmpty) {
-      error("User auth Database has not been configured!")
-      throw new IllegalArgumentException("User auth Database has not been configured!")
+    if (dbDriver.isEmpty) {
+      throw new IllegalArgumentException("JDBC driver class is not configured.")
+    }
+
+    if (dbUrl.isEmpty) {
+      throw new IllegalArgumentException("JDBC url is not configured")
+    }
+
+    if (dbUserName.isEmpty || dbPassword.isEmpty) {
+      throw new IllegalArgumentException("JDBC username or password is not configured")
     }
 
     // Check Query SQL
     if (querySql.isEmpty) {
-      error("Query SQL not configured!")
-      throw new IllegalArgumentException("Query SQL not configured!")
+      throw new IllegalArgumentException("Query SQL is not configured")
     }
     if (!querySql.get.trim.toLowerCase.startsWith("select")) { // only allow select query sql
-      error("Query SQL must start with \"select\"!")
-      throw new IllegalArgumentException("Query SQL must start with \"select\"!");
+      throw new IllegalArgumentException("Query SQL must start with \"SELECT\"");
     }
   }
 
@@ -159,9 +164,9 @@ class JdbcAuthenticationProviderImpl(conf: KyuubiConf) extends PasswdAuthenticat
    * @return
    */
   private def getAndPrepareStatement(
-      connection: Connection,
-      user: String,
-      password: String): PreparedStatement = {
+                                      connection: Connection,
+                                      user: String,
+                                      password: String): PreparedStatement = {
     // Replace placeholders by "?" and prepare the statement
     val stmt = connection.prepareStatement(getPreparedSql(querySql.get))
 

kyuubi-common/src/test/scala/org/apache/kyuubi/service/authentication/JdbcAuthenticationProviderImplSuite.scala

@@ -27,19 +27,20 @@ import org.apache.kyuubi.config.KyuubiConf
 import org.apache.kyuubi.config.KyuubiConf._
 
 class JdbcAuthenticationProviderImplSuite extends KyuubiFunSuite {
+  protected val dbUser: String = "bowenliang123"
+  protected val dbPasswd: String = "bowenliang123"
+  protected var jdbcUrl: String = _
+
   protected val authUser: String = "liangtiancheng"
   protected val authPasswd: String = "liangtiancheng"
 
-  protected val dbUser: String = "liangbowen"
-  protected val dbPasswd: String = "liangbowen"
-
-  protected var jdbcUrl: String = _
-
-  private val conf = new KyuubiConf()
+  protected var conf = new KyuubiConf()
   var conn: Connection = _
   var authDb: Path = _
 
   override def beforeAll(): Unit = {
+    super.beforeAll()
+
     val datasourceProperties = new Properties()
     datasourceProperties.put("user", dbUser)
     datasourceProperties.put("password", dbPasswd)
@@ -54,7 +55,7 @@ class JdbcAuthenticationProviderImplSuite extends KyuubiFunSuite {
         + ";password=" + dbPasswd,
       datasourceProperties)
 
-    conn.prepareStatement("create schema " + dbUser).execute();
+    conn.prepareStatement("CREATE SCHEMA " + dbUser).execute();
 
     conn.prepareStatement("CREATE TABLE user_auth (" +
       "username VARCHAR(64) NOT NULL PRIMARY KEY, " +
@@ -66,17 +67,12 @@ class JdbcAuthenticationProviderImplSuite extends KyuubiFunSuite {
     insertStmt.setString(2, authPasswd)
     insertStmt.execute();
 
-    conf.set(AUTHENTICATION_JDBC_DRIVER, "org.apache.derby.jdbc.AutoloadedDriver")
-    conf.set(AUTHENTICATION_JDBC_URL, jdbcUrl)
-    conf.set(AUTHENTICATION_JDBC_USERNAME, dbUser)
-    conf.set(AUTHENTICATION_JDBC_PASSWORD, dbPasswd)
-    conf.set(
-      AUTHENTICATION_JDBC_QUERY,
-      "select 1 from user_auth " +
-        "where username=${username} and passwd=${password}")
+    conf = genJdbcAuthConfigs
   }
 
   override def afterAll(): Unit = {
+    super.afterAll()
+
     // shutdown derby database
     try {
       DriverManager.getConnection(s"jdbc:derby:;databaseName=$authDb;shutdown=true")
@@ -85,23 +81,67 @@ class JdbcAuthenticationProviderImplSuite extends KyuubiFunSuite {
     }
   }
 
+  def genJdbcAuthConfigs: KyuubiConf = {
+    conf = new KyuubiConf()
+    conf.set(AUTHENTICATION_JDBC_DRIVER, "org.apache.derby.jdbc.AutoloadedDriver")
+    conf.set(AUTHENTICATION_JDBC_URL, jdbcUrl)
+    conf.set(AUTHENTICATION_JDBC_USERNAME, dbUser)
+    conf.set(AUTHENTICATION_JDBC_PASSWORD, dbPasswd)
+    conf.set(
+      AUTHENTICATION_JDBC_QUERY,
+      "SELECT 1 FROM user_auth " +
+        " WHERE username=${username} and passwd=${password}")
+    conf
+  }
+
   test("authenticate tests") {
     var providerImpl = new JdbcAuthenticationProviderImpl(conf)
 
+    providerImpl.authenticate(authUser, authPasswd)
+
     val e1 = intercept[AuthenticationException](providerImpl.authenticate("", ""))
     assert(e1.getMessage.contains("user is null"))
+
     val e2 = intercept[AuthenticationException](providerImpl.authenticate("kyuubi", ""))
     assert(e2.getMessage.contains("password is null"))
 
-    providerImpl.authenticate(authUser, authPasswd)
-
     val e4 = intercept[AuthenticationException](
       providerImpl.authenticate(authPasswd, "pass"))
     assert(e4.isInstanceOf[AuthenticationException])
 
+    conf = genJdbcAuthConfigs
     conf.unset(AUTHENTICATION_JDBC_URL)
     providerImpl = new JdbcAuthenticationProviderImpl(conf)
     val e5 = intercept[IllegalArgumentException](providerImpl.authenticate(authUser, authPasswd))
-    assert(e5.getMessage.contains("User auth Database has not been configured!"))
+    assert(e5.getMessage.contains("JDBC url is not configured"))
+
+    conf = genJdbcAuthConfigs
+    conf.unset(AUTHENTICATION_JDBC_USERNAME)
+    providerImpl = new JdbcAuthenticationProviderImpl(conf)
+    val e6 = intercept[IllegalArgumentException](providerImpl.authenticate(authUser, authPasswd))
+    assert(e6.getMessage.contains("JDBC username or password is not configured"))
+
+    conf = genJdbcAuthConfigs
+    conf.unset(AUTHENTICATION_JDBC_PASSWORD)
+    providerImpl = new JdbcAuthenticationProviderImpl(conf)
+    val e7 = intercept[IllegalArgumentException](providerImpl.authenticate(authUser, authPasswd))
+    assert(e7.getMessage.contains("JDBC username or password is not configured"))
+
+    conf = genJdbcAuthConfigs
+    conf.unset(AUTHENTICATION_JDBC_QUERY)
+    providerImpl = new JdbcAuthenticationProviderImpl(conf)
+    val e8 = intercept[IllegalArgumentException](providerImpl.authenticate(authUser, authPasswd))
+    assert(e8.getMessage.contains("Query SQL is not configured"))
+
+    conf.set(AUTHENTICATION_JDBC_QUERY, "INSERT INTO user_auth (username, password) " +
+      " VALUES ('demouser','demopassword'); ")
+    providerImpl = new JdbcAuthenticationProviderImpl(conf)
+    val e9 = intercept[IllegalArgumentException](providerImpl.authenticate(authUser, authPasswd))
+    assert(e9.getMessage.contains("Query SQL must start with \"SELECT\""))
+
+    conf.unset(AUTHENTICATION_JDBC_URL)
+    providerImpl = new JdbcAuthenticationProviderImpl(conf)
+    val e10 = intercept[IllegalArgumentException](providerImpl.authenticate(authUser, authPasswd))
+    assert(e10.getMessage.contains("JDBC url is not configured"))
   }
 }