如何使用ScalaMock计算该函数，使用参数调用该函数，并具有有用的输出

Question

我一直在看：

• http://scalamock.org/user-guide/advanced_topics/
• https://scalamock.org/user-guide/matching/
• https://scalamock.org/quick-start/

但还没有达到我想要的结果，实际上我做了这个测试

 scenario("myFunction reads parquet and writes to db") {
          var mockUtil: UtilitiesService = stub[UtilitiesService]
          val service = new myService(mockUtil)
          
          val expectedParquetDf = Seq(
              (999, "testData")
          ).toDF("number", "word")

          (mockUtil.getDataFrameFromParquet _).when("myParquetPath") returns Right(expectedParquetDf)
          service.publishToDatabase()
          (mockUtil.insertDataFrameIntoDb_).verify(expectedParquetDf,"myTable").once()        
      }

但是，如果测试失败(由于数据不匹配)，输出就不理想了，简单地说，

[info]   Expected:
[info]   inAnyOrder {
[info]     <stub-4> UtilitiesService.getDataFrameFromParquet(path) any number of times (called once)
[info]     <stub-4> UtilitiesService.insertDataFrameIntoPostgres[number: int, word: string] once (never called - UNSATISFIED)
[info]   }
[info]   
[info]   Actual:
[info]     <stub-4> UtilitiesService.getDataFrameFromParquet(oath)
[info]     <stub-4> UtilitiesService.insertDataFrameIntoPostgres([number: int, word: string], "myTable" (myFile.scala:28)

字符串部分是spot的，但是dataframe部分；只有当一个列被删除时才有用，如果有坏的行，那么就更少了等等，这有一个很好的改进方法吗？

目前，我的兔子洞已经引导我到下面，它仍然不工作，“断言”函数返回真实的“&”部分工作，所有的感觉，必须有一个更好的方法。在标准验证中是否有更好的函数可以重写？：

  def assertStringsAreEqual(expectedPath:String, actualPath:String) : Boolean = {
          assert(actualPath == expectedPath)
          true
      }

      def assertDataFramesAreEqual(expected: DataFrame, actual: DataFrame) : Boolean = {
          AssertHelpers.assertDataEqual(expected, actual) //verbos info, asserts on each row etc
          true
      }


      scenario("myFunction reads parquet and writes to db") {
          var mockUtil: UtilitiesService = stub[UtilitiesService]
          val service = new myService(mockUtil)
          val expectedParquetDf = Seq(
              (999, "testData"),
              (898, "wrongData"),
              (999, "extraRow")
          ).toDF("number", "word")

          val incorrectExample = Seq(
              (999, "testData"),
              (999, "testData")
          ).toDF("number", "word")

          (mockUtil.getDataFrameFromParquet _).when("myParquetPath") returns Right(incorrectExample) //forced to incorrect for now
          (_mockUtilService.insertDataFrameIntoPostgres _).
              expects(where { {
                      (actualDf, path) => assertDataFramesAreEqual(expectedParquetDf, actualDf) && assertStringsAreEqual(path, "ExpectedTable")
              }  })
              .once()

          service.publishToDb()

      }

作为参考，我的目标是在某个地方出现这样的东西：

Expected:
Dataframe:
[number, word]
[999, "testData"]
[898, "wrongData"]
[999, "extraRow"]

Actual:
Dataframe
[number, word]
[999, "testData"]
[999, "testData"]

Answer 1

所以这仍然不理想，但是使用"expects.onCall“我可以得到我想要的输出

scenario("myFunction reads parquet and writes to db") {
      var mockUtil: UtilitiesService = mock[UtilitiesService]
      val service = new myService(mockUtil)
      val expectedParquetDf = Seq(
          (999, "testData"),
          (898, "wrongData"),
          (999, "extraRow")
      ).toDF("number", "word")

      val incorrectExample = Seq(
          (999, "testData"),
          (999, "testData")
      ).toDF("number", "word")

     //set up expectations
      (mockUtilService.insertDataFrameIntoPostgres _).expects(*,"ExpectedTable").onCall( { (df: DataFrame, path:String) =>
        AssertHelpers.assertDataEqual(df, expectedParquetDf)
        Right(sxDbData)
        })


      (mockUtil.getDataFrameFromParquet _).when("myParquetPath") returns Right(incorrectExample) //forced to incorrect for now

      service.publishToDb()

  }

希望有人能找到一个更干净的解决方案