Refactor: Split AdminSuite and set up route-specific test cases

- Separated AdminSuite into individual test cases based on routes.
- Created directory structure for CatalogSuite.
- Updated TestPostAdminReload test cases with Seq-based data setup.

- Verified all tests pass successfully.

Signed-off-by: cutiechicken <[email protected]>

Author: cutiechicken

src/test/scala/org/openhorizon/exchangeapi/route/administration/TestDeleteOrgChanges.scala

@@ -0,0 +1,38 @@
+package org.openhorizon.exchangeapi.route.administration
+
+import org.json4s.DefaultFormats
+import org.json4s.jackson.Serialization.write
+import org.scalatest.BeforeAndAfterAll
+import org.scalatest.funsuite.AnyFunSuite
+import scalaj.http.Http
+import org.openhorizon.exchangeapi.utility.{ApiUtils, HttpCode}
+import org.openhorizon.exchangeapi.auth.Role
+import org.openhorizon.exchangeapi.utility.Configuration
+
+class TestDeleteOrgChanges extends AnyFunSuite with BeforeAndAfterAll {
+  private val ACCEPT = ("Accept", "application/json")
+  private val CONTENT = ("Content-Type", "application/json")
+  private val ROOTAUTH = ("Authorization", "Basic " + ApiUtils.encode(Role.superUser + ":" + (try Configuration.getConfig.getString("api.root.password") catch { case _: Exception => "" })))
+  private val API_URL = sys.env.getOrElse("EXCHANGE_URL_ROOT", "http://localhost:8080") + "/v1/orgs/"
+  private implicit val formats: DefaultFormats.type = DefaultFormats
+  // have to insert some data first, will update later
+  // test("DELETE /orgs/root/changes/cleanup - should return 204 NO CONTENT") {
+  //   val input = DeleteOrgChangesRequest(List("admin", "user", "agbot", "pattern", "node", "service", "hubadmin"))
+  //   val response = Http(API_URL + "root/changes/cleanup").postData(write(input))
+  //     .method("delete").headers(CONTENT).headers(ACCEPT).headers(ROOTAUTH).asString
+
+  //   info("http status code: " + response.code)
+  //   info("response body: " + response.body)
+  //   assert(response.code === HttpCode.DELETED.intValue)
+  // }
+
+  // test("DELETE /orgs/{org}/changes/cleanup - should return 204 NO CONTENT for specific org") {
+  //   val input = DeleteOrgChangesRequest(List())
+  //   val response = Http(API_URL + "someOrg/changes/cleanup").postData(write(input))
+  //     .method("delete").headers(CONTENT).headers(ACCEPT).headers(ROOTAUTH).asString
+
+  //   info("http status code: " + response.code)
+  //   info("response body: " + response.body)
+  //   assert(response.code === HttpCode.DELETED.intValue)
+  // }
+}

src/test/scala/org/openhorizon/exchangeapi/route/administration/TestGetAdminStatus.scala

@@ -563,7 +563,15 @@ class TestGetAdminStatus extends AnyFunSuite with BeforeAndAfterAll {
     assert(status.numberOfUsers.get === 5)
     assert(status.SchemaVersion.isEmpty)
   }
-  
+
+  test("GET /admin/status" + " -- root - 401 invalid credentials") {
+  val response: HttpResponse[String] = Http("http://0.0.0.0:8080/v1/" + "admin/status").headers(ACCEPT).headers(("Authorization","Basic " + ApiUtils.encode(Role.superUser + ":" + "invalidpassword"))).asString
+  info("Code: " + response.code)
+  info("Body: " + response.body)
+  assert(response.code === HttpCode.BADCREDS.intValue)
+}
+
+
   test("GET /admin/status" + " -- hub admin - 200 ok - normal success", AdminStatusTest) {
     val response: HttpResponse[String] = Http("http://0.0.0.0:8080/v1/" + "admin/status").headers(ACCEPT).headers(HUBADMINAUTH).asString
     info("Code: " + response.code)

src/test/scala/org/openhorizon/exchangeapi/route/administration/TestGetAdminVersion.scala

@@ -0,0 +1,20 @@
+package org.openhorizon.exchangeapi.route.administration
+
+import org.json4s.DefaultFormats
+import org.scalatest.funsuite.AnyFunSuite
+import scalaj.http.Http
+import org.openhorizon.exchangeapi.utility.{ApiUtils, HttpCode}
+import org.openhorizon.exchangeapi.utility.Configuration
+
+class TestGetAdminVersion extends AnyFunSuite {
+  private val ACCEPTTEXT = ("Accept", "text/plain")
+  private val API_URL = sys.env.getOrElse("EXCHANGE_URL_ROOT", "http://localhost:8080") + "/v1/admin/version"
+
+  test("GET /admin/version - should return 200 OK with version info") {
+    val response = Http(API_URL).headers(ACCEPTTEXT).asString
+
+    info("http status code: " + response.code)
+    info("version: " + response.body)
+    assert(response.code === HttpCode.OK.intValue)
+  }
+}

src/test/scala/org/openhorizon/exchangeapi/route/administration/TestPostAdminHashpw.scala

@@ -0,0 +1,149 @@
+package org.openhorizon.exchangeapi.route.administration
+import scala.collection.immutable.List
+import scala.collection.mutable.ListBuffer
+import org.openhorizon.exchangeapi.table.organization.OrgRow
+import org.openhorizon.exchangeapi.utility.{ApiTime, Configuration}
+import org.json4s.DefaultFormats
+import org.json4s.jackson.JsonMethods.parse
+import org.junit.runner.RunWith
+import org.scalatest.BeforeAndAfterAll
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatestplus.junit.JUnitRunner
+import org.openhorizon.exchangeapi.auth.{Password, Role}
+import org.openhorizon.exchangeapi.utility.{ApiUtils, HttpCode}
+import org.openhorizon.exchangeapi.route.administration.{AdminHashpwRequest, AdminHashpwResponse}
+import org.json4s.jackson.Serialization.write
+import scalaj.http.Http
+import org.openhorizon.exchangeapi.route.organization.PostPutOrgRequest
+import org.openhorizon.exchangeapi.route.service.PostPutServiceRequest
+import org.openhorizon.exchangeapi.route.node.PutNodesRequest
+import org.openhorizon.exchangeapi.route.agreementbot.PutAgbotsRequest
+import org.openhorizon.exchangeapi.route.deploymentpattern.PostPutPatternRequest
+import org.openhorizon.exchangeapi.route.user.PostPutUsersRequest
+import org.openhorizon.exchangeapi.table.deploymentpattern.{PServiceVersions, PServices}
+@RunWith(classOf[JUnitRunner])
+class TestPostAdminHashpw extends AnyFunSuite with BeforeAndAfterAll {
+
+ private val ACCEPT              = ("Accept", "application/json")
+  private val ACCEPTTEXT          = ("Accept", "text/plain")
+  private val AGBOT: String       = "agbot"
+  private val CONTENT             = ("Content-Type", "application/json")
+  private val NODE: String        = "node"
+  private val PATTERN: String     = "pattern"
+  private val ROOTAUTH            = ("Authorization","Basic " + ApiUtils.encode(Role.superUser + ":" + (try Configuration.getConfig.getString("api.root.password") catch { case _: Exception => "" })))
+  private val SERVICE: String     = "service"
+  private val URL                 = sys.env.getOrElse("EXCHANGE_URL_ROOT", "http://localhost:8080") + "/v1"
+  private val USERS: List[String] = List("admin", "user")
+  private val ORGS: List[String]  = List("adminsuite", "root")
+  private val hubadmin            = "AdminSuitTestsHubAdmin"
+  private val urlRootOrg          =  URL + "/orgs/root"
+  private val pw                  = "password"
+  private val HUBADMINAUTH        = ("Authorization", "Basic " + ApiUtils.encode("root/"+hubadmin+":"+pw))
+  private val orgsList            = List(ORGS.head)
+  private var resources           = new ListBuffer[String]()
+
+  implicit val FORMATS: DefaultFormats.type = DefaultFormats // Brings in default date formats etc.
+
+  val TESTORGS: Seq[OrgRow] =
+    Seq(OrgRow(description = "AdminSuite Test Organization",
+               heartbeatIntervals = "",
+               label = "",
+               lastUpdated = ApiTime.nowUTC,
+               limits = "",
+               orgId = "admin",
+               orgType = "",
+               tags = None))
+  
+  override def beforeAll(): Unit = {
+    Http(URL + "/orgs/" + ORGS(0)).postData(write(PostPutOrgRequest(None, (ORGS(0)), "AdminSuite Test Organization", None, None, None))).method("post").headers(CONTENT).headers(ACCEPT).headers(ROOTAUTH).asString
+
+    for (org <- ORGS) {
+      for (user <- USERS) {
+        val response = Http(URL + "/orgs/" + org + "/users/" + user).postData(write(PostPutUsersRequest(password="password", admin=user.endsWith("admin") && org!="root", hubAdmin=Some(org=="root"), email=user + "@host.domain"))).method("post").headers(CONTENT).headers(ACCEPT).headers(ROOTAUTH).asString
+        assert(response.code == HttpCode.POST_OK.intValue)
+      }
+      var response = Http(URL + "/orgs/" + org + "/agbots/" + AGBOT).postData(write(PutAgbotsRequest("TokAbcDefGh1234", AGBOT, None, "password"))).method("put").headers(CONTENT).headers(ACCEPT).headers(ROOTAUTH).asString
+      assert(response.code == HttpCode.PUT_OK.intValue)
+      response = Http(URL + "/orgs/" + org + "/services").postData(write(PostPutServiceRequest(SERVICE, None, public = true, None, URL + "/orgs/" + org + "/services/" + SERVICE, "0.0.1", "test-arch", "multiple", None, None, None, None, None, None, None, None ))).method("post").headers(CONTENT).headers(ACCEPT).headers(ROOTAUTH).asString
+      assert(response.code == HttpCode.POST_OK.intValue)
+      response = Http(URL + "/orgs/" + org + "/patterns/" + PATTERN).postData(write(PostPutPatternRequest(PATTERN, Some("AdminSuite Test Pattern"), None, List(PServices(URL + "/orgs/" + org + "/services/" + SERVICE, org, "test-arch", None, List(PServiceVersions("0.0.1", None, None, None, None)), None, None)), None, None, None))).method("post").headers(CONTENT).headers(ACCEPT).headers(ROOTAUTH).asString
+      assert(response.code == HttpCode.POST_OK.intValue)
+      response = Http(URL + "/orgs/" + org + "/nodes/" + NODE).postData(write(PutNodesRequest("TokAbcDefGh1234", NODE, None, org + "/" + PATTERN, None, None, None, None, "password", None, None))).method("put").headers(CONTENT).headers(ACCEPT).headers(ROOTAUTH).asString
+      assert(response.code == HttpCode.PUT_OK.intValue)
+    }
+  }
+
+  override def afterAll(): Unit = {
+    for (org <- ORGS) {
+      for (user <- USERS) {
+        val response = Http(URL + "/orgs/" + org + "/users/" + user).method("delete").headers(ACCEPT).headers(ROOTAUTH).asString
+        assert(response.code == HttpCode.DELETED.intValue)
+      }
+      
+      var response = Http(URL + "/orgs/" + org + "/agbots/" + AGBOT).method("delete").headers(ACCEPT).headers(ROOTAUTH).asString
+      assert(response.code == HttpCode.DELETED.intValue)
+      response = Http(URL + "/orgs/" + org + "/nodes/" + NODE).method("delete").headers(ACCEPT).headers(ROOTAUTH).asString
+      assert(response.code == HttpCode.DELETED.intValue)
+      response = Http(URL + "/orgs/" + org + "/patterns/" + PATTERN).method("delete").headers(ACCEPT).headers(ROOTAUTH).asString
+      assert(response.code == HttpCode.DELETED.intValue)
+      response = Http(URL + "/orgs/" + org + "/services/" + ("/".r.replaceAllIn(("""(http[sS]{0,1}://(www.){0,1}){0,1}""".r.replaceFirstIn(URL, "")), "-")) + "-orgs-" + org + "-services-" + SERVICE + "_0.0.1_test-arch").method("delete").headers(ACCEPT).headers(ROOTAUTH).asString
+      assert(response.code == HttpCode.DELETED.intValue)
+    }
+    
+    val response = Http(URL + "/orgs/" + ORGS(0)).method("delete").headers(ACCEPT).headers(ROOTAUTH).asString
+    assert(response.code == HttpCode.DELETED.intValue)
+  }
+ // =============== Hash a Password ===============
+  for (org <- ORGS) {
+    test("POST /admin/hashpw - " + org + "/" + AGBOT) {
+      val input = AdminHashpwRequest("foobar")
+      val response = Http(URL + "/admin/hashpw").postData(write(input)).headers(CONTENT).headers(ACCEPT).headers(("Authorization","Basic " + ApiUtils.encode(org + "/" + AGBOT + ":" + "TokAbcDefGh1234"))).asString
+      info("http status code: " + response.code)
+      info("body: " + response.body)
+      assert(response.code === HttpCode.ACCESS_DENIED.intValue)
+    }
+  }
+
+  for (org <- ORGS) {
+    test("POST /admin/hashpw - " + org + "/" + NODE) {
+      val input = AdminHashpwRequest("foobar")
+      val response = Http(URL + "/admin/hashpw").postData(write(input)).headers(CONTENT).headers(ACCEPT).headers(("Authorization","Basic " + ApiUtils.encode(org + "/" + NODE + ":" + "TokAbcDefGh1234"))).asString
+      info("http status code: " + response.code)
+      info("body: " + response.body)
+      assert(response.code === HttpCode.ACCESS_DENIED.intValue)
+    }
+  }
+
+  for (org <- ORGS) {
+    for (user <- USERS) {
+      test("POST /admin/hashpw - " + org + "/" + user) {
+        val input = AdminHashpwRequest("foobar")
+        val response = Http(URL + "/admin/hashpw").postData(write(input)).headers(CONTENT).headers(ACCEPT).headers(("Authorization","Basic " + ApiUtils.encode(org + "/" + user + ":" + "password"))).asString
+        info("http status code: " + response.code)
+        info("body: " + response.body)
+        assert(response.code === HttpCode.POST_OK.intValue)
+        val postResp = parse(response.body).extract[AdminHashpwResponse]
+        assert(Password.check(input.password, postResp.hashedPassword))
+      }
+    }
+  }
+
+  test("POST /admin/hashpw - root/root") {
+    val input = AdminHashpwRequest("foobar")
+    val response = Http(URL + "/admin/hashpw").postData(write(input)).headers(CONTENT).headers(ACCEPT).headers(ROOTAUTH).asString
+    info("http status code: " + response.code)
+    info("body: " + response.body)
+    assert(response.code === HttpCode.POST_OK.intValue)
+    val postResp = parse(response.body).extract[AdminHashpwResponse]
+    assert(Password.check(input.password, postResp.hashedPassword))
+  }
+
+  test("POST /admin/hashpw - root/root - Invaild Credentials") {
+    val input = AdminHashpwRequest("foobar")
+    val response = Http(URL + "/admin/hashpw").postData(write(input)).headers(CONTENT).headers(ACCEPT).headers(("Authorization","Basic " + ApiUtils.encode(Role.superUser + ":" + "invaildcredentials"))).asString
+    info("http status code: " + response.code)
+    info("body: " + response.body)
+    assert(response.code === HttpCode.BADCREDS.intValue)
+  }
+
+}