scala - 我将如何在 Scala 中注入(inject)一个模拟的单例对象？

Question

我们正在使用 Scala 2.10.2，我们正在使用 Slick 1.0.1 用于我们的 DAO。我们正在尝试使用 ScalaMock 模拟 DAO。 ，并且我正在尝试找出一种注入(inject)模拟 DAO 的好方法。我已经使用 Java 好几年了，但两周前我才开始使用 Scala。

现在我们的代码看起来像(忽略任何语法错误，我已经压缩了代码，但没有确保它仍然满足类型系统)

abstract class RichTable[T](name: String) 
        extends slick.driver.MySQLDriver.simple.Table[T](name) {
    type ItemType = T
    def id = column[Int]("id", O.PrimaryKey, O.AutoInc)
    ...
}

object Users extends RichTable[User]("users") {
    def crypted_password = column[String]("crypted_password")
    ...
}

case class User(id: Option[Int] = None, crypted_password: String) {
    def updatePassword(...) = {
        Users.where(_.id === id).map{e => e.crypted_password}.update("asdf")
    }
}

所有的 DAO 都是继承自 RichTable[T] 的单例对象。

我们希望能够模拟用户和其他单例 DAO 对象——现在我们所有的单元测试都在访问数据库。然而，我们遇到的问题是如何注入(inject)模拟单例对象。到目前为止，我们提出的解决方案是:

object DAORepo {
    var usersDAO : Users.type = Users
    var anotherDAO : Another.type = Another
    ...
}

object Users extends RichTable[User]("users") {
    def apply() : Users.type = DAORepos.usersDAO
}

def updatePassword(...) = {
    Users().where(_.id === id).map{e => e.crypted_password}.update("asdf")
}

def test = {
    val mockUsers = mock[Users]
    DAORepo.usersDAO = mockUsers
    // run test using mock repo
}

我们正在从 Users 更改所有引用至 Users() ，这不会增加过多的困惑。但是， DAORepo 中 vars 的使用闻起来很糟糕，我想知道是否有人有改进的建议。

我已阅读 Real-World Scala: Dependency Injection (DI)和 Component Based Dependency Injection in Scala - 我想我知道如何使用特征来组成 DAORepo，比如

trait UsersRepo {
    val usersDAO : Users.type = Users
}

trait DAORepo extends UsersRepo with AnotherRepo { }

trait UsersTestRepo {
    val usersDAO : Users.type = mock[Users]
}

但我仍然不明白如何注入(inject)新特征。我可以做类似的事情

class DAORepoImpl extends DAORepo { }

object DAOWrapper {
    var repo : DAORepo = new DAORepoImpl
}

def test = {
    DAOWrapper.repo = new DAORepoImpl with UsersTestRepo
}

替换 object DAORepo 中的两打变量 object DAOWrapper 中有一个 var ，但似乎应该有一种干净的方法来做到这一点，而无需任何变量。

Answer 1

我不明白你所有的类(class)和你的特质。

trait UsersRepo {
    val usersDAO : Users.type = Users
}

trait AnotherRepo {
    val anotherDAO : Another.type = Another
}

trait DAORepo extends UsersRepo with AnotherRepo

然后你就可以实例化一个真正的 RealDAORepo

object RealDAORepo extends DAORepo { }

或者被 mock 的

object MockedDAORepo extends DAORepo {
  override val usersDAO : Users.type = mock[Users]
  override val anotherDAO : Another.type = mock[Another]
}

然后在你的应用程序中注入(inject) DAORepo，你可以使用 cake 模式和 self 类型引用来做到这一点。

我很快会在 InfoQ FR 上发表一篇文章，帮助 Spring 的人们理解蛋糕模式。这是本文的代码示例:

trait UserTweetServiceComponent {
  val userTweetService: UserTweetService
}

trait UserTweetService {
  def createUser(user: User): User
  def createTweet(tweet: Tweet): Tweet
  def getUser(id: String): User
  def getTweet(id: String): Tweet
  def getUserAndTweets(id: String): (User,List[Tweet])
}

trait DefaultUserTweetServiceComponent extends UserTweetServiceComponent {

  // Declare dependencies of the service here
  self: UserRepositoryComponent 
        with TweetRepositoryComponent =>

  override val userTweetService: UserTweetService = new DefaultUserTweetService

  class DefaultUserTweetService extends UserTweetService {
    override def createUser(user: User): User = userRepository.createUser(user)
    override def createTweet(tweet: Tweet): Tweet = tweetRepository.createTweet(tweet)
    override def getUser(id: String): User = userRepository.getUser(id)
    override def getTweet(id: String): Tweet = tweetRepository.getTweet(id)
    override def getUserAndTweets(id: String): (User,List[Tweet]) = {
      val user = userRepository.getUser(id)
      val tweets = tweetRepository.getAllByUser(user)
      (user,tweets)
    }
  }
}

请注意，这与 Spring 声明几乎相同:

<bean name="userTweetService" class="service.impl.DefaultUserTweetService">
    <property name="userRepository" ref="userRepository"/>
    <property name="tweetRepository" ref="tweetRepository"/>
</bean>

当你这样做时:

trait MyApplicationMixin
  extends DefaultUserTweetServiceComponent
  with InMemoryUserRepositoryComponent
  with InMemoryTweetRepositoryComponent

它与 Spring 声明几乎相同(但您获得了类型安全的应用程序上下文):

<import resource="classpath*:/META-INF/application-context-default-tweet-services.xml" />
<import resource="classpath*:/META-INF/application-context-inmemory-tweet-repository.xml" />
<import resource="classpath*:/META-INF/application-context-inmemory-user-repository.xml" />

然后，您可以使用该应用程序:

val app = new MyApplicationMixin { }

或者

val app = new MyApplicationMixin { 
   override val tweetRepository = mock[TweetRepository]
}

后者将与 Spring bean 覆盖相同:

<import resource="classpath*:/META-INF/application-context-default-tweet-services.xml" />
<import resource="classpath*:/META-INF/application-context-inmemory-tweet-repository.xml" />
<import resource="classpath*:/META-INF/application-context-inmemory-user-repository.xml" />

 <!-- 
 This bean will override the one defined in application-context-inmemory-tweet-repository.xml
 But notice that Spring isn't really helpful to declare the behavior of the mock, which is much 
 easier with the cake pattern since you directly write code
 -->
<bean id="tweetRepository" class="repository.impl.MockedTweetRepository"/>

所以回到你的问题，你可以使用蛋糕模式并在你的应用程序中创建服务组件，这取决于你的 DAORepo 特征。

然后你可以这样做:

trait MyApplicationMixin
      extends DefaultUserServiceComponent
      with AnotherServiceComponent
      with DAORepo

进而:

val app = new MyApplicationMixin { }

或者

val app = new MyApplicationMixin {
    override val usersDAO : Users.type = mock[Users]
    override val anotherDAO : Another.type = mock[Another]
}

构建应用程序后，您可以像这样使用它:

app.userService.createUser(...)

构建的应用程序真的就像一个应用程序上下文