add more tests

* also make auth provider more powerful

src/main/scala/me/arcanis/ffxivbis/http/Authorization.scala

@@ -37,23 +37,16 @@ trait Authorization {
   def authAdmin(partyId: String)(username: String, password: String)(implicit
     executionContext: ExecutionContext
   ): Future[Option[User]] =
-    authenticator(Permission.admin, partyId)(username, password)
+    auth.authenticator(Permission.admin, partyId)(username, password)
 
   def authGet(partyId: String)(username: String, password: String)(implicit
     executionContext: ExecutionContext
   ): Future[Option[User]] =
-    authenticator(Permission.get, partyId)(username, password)
+    auth.authenticator(Permission.get, partyId)(username, password)
 
   def authPost(partyId: String)(username: String, password: String)(implicit
     executionContext: ExecutionContext
   ): Future[Option[User]] =
-    authenticator(Permission.post, partyId)(username, password)
+    auth.authenticator(Permission.post, partyId)(username, password)
 
-  private def authenticator(scope: Permission.Value, partyId: String)(username: String, password: String)(implicit
-    executionContext: ExecutionContext
-  ): Future[Option[User]] =
-    auth.get(partyId, username).map {
-      case Some(user) if user.verify(password) && user.verityScope(scope) => Some(user)
-      case _ => None
-    }
 }

src/main/scala/me/arcanis/ffxivbis/http/AuthorizationProvider.scala

@@ -14,19 +14,31 @@ import akka.util.Timeout
 import com.google.common.cache.{CacheBuilder, CacheLoader, LoadingCache}
 import com.typesafe.config.Config
 import me.arcanis.ffxivbis.messages.{GetUser, Message}
-import me.arcanis.ffxivbis.models.User
+import me.arcanis.ffxivbis.models.{Permission, User}
 
 import java.util.concurrent.TimeUnit
-import scala.concurrent.Future
+import scala.concurrent.{ExecutionContext, Future}
 
 trait AuthorizationProvider {
 
   def get(partyId: String, username: String): Future[Option[User]]
+
+  def authenticator[T](scope: Permission.Value, partyId: String)(username: String, password: String)(implicit
+    executionContext: ExecutionContext,
+    extractor: User => T
+  ): Future[Option[T]] =
+    get(partyId, username).map {
+      case Some(user) if user.verify(password) && user.verityScope(scope) => Some(extractor(user))
+      case _ => None
+    }
 }
 
 object AuthorizationProvider {
 
-  def apply(config: Config, storage: ActorRef[Message], timeout: Timeout, scheduler: Scheduler): AuthorizationProvider =
+  def apply(config: Config, storage: ActorRef[Message])(implicit
+    timeout: Timeout,
+    scheduler: Scheduler
+  ): AuthorizationProvider =
     new AuthorizationProvider {
       private val cacheSize = config.getInt("me.arcanis.ffxivbis.web.authorization-cache.cache-size")
       private val cacheTimeout =

src/main/scala/me/arcanis/ffxivbis/http/RootEndpoint.scala

@@ -28,7 +28,7 @@ class RootEndpoint(system: ActorSystem[Nothing], storage: ActorRef[Message], pro
   implicit val scheduler: Scheduler = system.scheduler
   implicit val timeout: Timeout = config.getTimeout("me.arcanis.ffxivbis.settings.request-timeout")
 
-  private val auth = AuthorizationProvider(config, storage, timeout, scheduler)
+  private val auth = AuthorizationProvider(config, storage)
 
   private val rootApiV1Endpoint = new RootApiV1Endpoint(storage, auth, provider, config)
   private val rootView = new RootView(auth)

src/main/scala/me/arcanis/ffxivbis/messages/DatabaseMessage.scala

@@ -8,36 +8,38 @@
  */
 package me.arcanis.ffxivbis.messages
 
-import akka.actor.typed.{ActorRef, Behavior}
+import akka.actor.typed.ActorRef
 import me.arcanis.ffxivbis.models._
 import me.arcanis.ffxivbis.service.LootSelector
 
 sealed trait DatabaseMessage extends Message {
 
   def partyId: String
-}
 
-object DatabaseMessage {
-
-  type Handler = PartialFunction[DatabaseMessage, Behavior[DatabaseMessage]]
+  def isReadOnly: Boolean
 }
 
 // bis handler
 trait BisDatabaseMessage extends DatabaseMessage
 
 case class AddPieceToBis(playerId: PlayerId, piece: Piece, replyTo: ActorRef[Unit]) extends BisDatabaseMessage {
-  override def partyId: String = playerId.partyId
+  override val partyId: String = playerId.partyId
+  override val isReadOnly: Boolean = false
 }
 
 case class GetBiS(partyId: String, playerId: Option[PlayerId], replyTo: ActorRef[Seq[Player]])
-  extends BisDatabaseMessage
+  extends BisDatabaseMessage {
+  override val isReadOnly: Boolean = true
+}
 
 case class RemovePieceFromBiS(playerId: PlayerId, piece: Piece, replyTo: ActorRef[Unit]) extends BisDatabaseMessage {
-  override def partyId: String = playerId.partyId
+  override val partyId: String = playerId.partyId
+  override val isReadOnly: Boolean = false
 }
 
 case class RemovePiecesFromBiS(playerId: PlayerId, replyTo: ActorRef[Unit]) extends BisDatabaseMessage {
-  override def partyId: String = playerId.partyId
+  override val partyId: String = playerId.partyId
+  override val isReadOnly: Boolean = false
 }
 
 // loot handler
@@ -45,54 +47,77 @@ trait LootDatabaseMessage extends DatabaseMessage
 
 case class AddPieceTo(playerId: PlayerId, piece: Piece, isFreeLoot: Boolean, replyTo: ActorRef[Unit])
   extends LootDatabaseMessage {
-  override def partyId: String = playerId.partyId
+  override val partyId: String = playerId.partyId
+  override val isReadOnly: Boolean = false
 }
 
 case class GetLoot(partyId: String, playerId: Option[PlayerId], replyTo: ActorRef[Seq[Player]])
-  extends LootDatabaseMessage
+  extends LootDatabaseMessage {
+  override val isReadOnly: Boolean = true
+}
 
 case class RemovePieceFrom(playerId: PlayerId, piece: Piece, isFreeLoot: Boolean, replyTo: ActorRef[Unit])
   extends LootDatabaseMessage {
-  override def partyId: String = playerId.partyId
+  override val partyId: String = playerId.partyId
+  override val isReadOnly: Boolean = false
 }
 
 case class SuggestLoot(partyId: String, piece: Piece, replyTo: ActorRef[LootSelector.LootSelectorResult])
-  extends LootDatabaseMessage
+  extends LootDatabaseMessage {
+  override val isReadOnly: Boolean = true
+}
 
 // party handler
 trait PartyDatabaseMessage extends DatabaseMessage
 
 case class AddPlayer(player: Player, replyTo: ActorRef[Unit]) extends PartyDatabaseMessage {
-  override def partyId: String = player.partyId
+  override val partyId: String = player.partyId
+  override val isReadOnly: Boolean = false
 }
 
-case class GetParty(partyId: String, replyTo: ActorRef[Party]) extends PartyDatabaseMessage
+case class GetParty(partyId: String, replyTo: ActorRef[Party]) extends PartyDatabaseMessage {
+  override val isReadOnly: Boolean = true
+}
 
-case class GetPartyDescription(partyId: String, replyTo: ActorRef[PartyDescription]) extends PartyDatabaseMessage
+case class GetPartyDescription(partyId: String, replyTo: ActorRef[PartyDescription]) extends PartyDatabaseMessage {
+  override val isReadOnly: Boolean = true
+}
 
 case class GetPlayer(playerId: PlayerId, replyTo: ActorRef[Option[Player]]) extends PartyDatabaseMessage {
-  override def partyId: String = playerId.partyId
+  override val partyId: String = playerId.partyId
+  override val isReadOnly: Boolean = true
 }
 
 case class RemovePlayer(playerId: PlayerId, replyTo: ActorRef[Unit]) extends PartyDatabaseMessage {
-  override def partyId: String = playerId.partyId
+  override val partyId: String = playerId.partyId
+  override val isReadOnly: Boolean = false
 }
 
 case class UpdateParty(partyDescription: PartyDescription, replyTo: ActorRef[Unit]) extends PartyDatabaseMessage {
-  override def partyId: String = partyDescription.partyId
+  override val partyId: String = partyDescription.partyId
+  override val isReadOnly: Boolean = false
 }
 
 // user handler
 trait UserDatabaseMessage extends DatabaseMessage
 
 case class AddUser(user: User, isHashedPassword: Boolean, replyTo: ActorRef[Unit]) extends UserDatabaseMessage {
-  override def partyId: String = user.partyId
+  override val partyId: String = user.partyId
+  override val isReadOnly: Boolean = false
 }
 
-case class DeleteUser(partyId: String, username: String, replyTo: ActorRef[Unit]) extends UserDatabaseMessage
+case class DeleteUser(partyId: String, username: String, replyTo: ActorRef[Unit]) extends UserDatabaseMessage {
+  override val isReadOnly: Boolean = true
+}
 
-case class Exists(partyId: String, replyTo: ActorRef[Boolean]) extends UserDatabaseMessage
+case class Exists(partyId: String, replyTo: ActorRef[Boolean]) extends UserDatabaseMessage {
+  override val isReadOnly: Boolean = true
+}
 
-case class GetUser(partyId: String, username: String, replyTo: ActorRef[Option[User]]) extends UserDatabaseMessage
+case class GetUser(partyId: String, username: String, replyTo: ActorRef[Option[User]]) extends UserDatabaseMessage {
+  override val isReadOnly: Boolean = true
+}
 
-case class GetUsers(partyId: String, replyTo: ActorRef[Seq[User]]) extends UserDatabaseMessage
+case class GetUsers(partyId: String, replyTo: ActorRef[Seq[User]]) extends UserDatabaseMessage {
+  override val isReadOnly: Boolean = true
+}

src/main/scala/me/arcanis/ffxivbis/service/PartyService.scala

@@ -16,7 +16,6 @@ import com.typesafe.scalalogging.StrictLogging
 import me.arcanis.ffxivbis.messages._
 import me.arcanis.ffxivbis.models.Party
 
-import scala.concurrent.duration.FiniteDuration
 import scala.concurrent.{ExecutionContext, Future}
 
 class PartyService(context: ActorContext[Message], storage: ActorRef[DatabaseMessage])
@@ -62,7 +61,8 @@ class PartyService(context: ActorContext[Message], storage: ActorRef[DatabaseMes
 
     case req: DatabaseMessage =>
       storage ! req
-      Behaviors.receiveMessage(handle(cache - req.partyId))
+      val result = if (req.isReadOnly) cache else cache - req.partyId
+      Behaviors.receiveMessage(handle(result))
   }
 
   private def getPartyId: Future[String] = {