fun configureSubmissionsResponses()

in intellij-plugin/educational-core/testSrc/com/jetbrains/edu/learning/marketplace/MarketplaceSubmissionsTest.kt [273:343]
62 lines of code
7 McCabe index (conditional complexity)

    fun configureSubmissionsResponses(
      submissionsLists: List<String> = listOf(loadSubmissionsData),
      statesOnCloseList: List<String> = emptyList(),
      solutionsKeyTextMap: Map<String, String> = emptyMap(),
      submissionsDeleteRequestSuccess: Boolean = false,
      reportSolutionRequestSuccess: Boolean = false,
    ) {
      mockkConstructor(Retrofit::class)
      val service = mockk<SubmissionsService>()
      every {
        anyConstructed<Retrofit>().create(SubmissionsService::class.java)
      } returns service

      val mapper = MarketplaceSubmissionsConnector.getInstance().objectMapper

      for (i in submissionsLists.indices) {
        val getAllSubmissionsPageableCall = mockk<Call<MarketplaceSubmissionsList>>()
        every { service.getAllSubmissionsForCourse(any(), i + 1) } returns getAllSubmissionsPageableCall
        val getAllSubmissionsPageableResponse = mapper.treeToValue(mapper.readTree(submissionsLists[i]), MarketplaceSubmissionsList::class.java)
        every { getAllSubmissionsPageableCall.execute() } returns Response.success(getAllSubmissionsPageableResponse)
      }

      for (i in statesOnCloseList.indices) {
        val getAllStatesPageableCall = mockk<Call<MarketplaceStateOnCloseList>>()
        every { service.getStateOnClose(any(), i + 1) } returns getAllStatesPageableCall
        val getAllStatesPageableResponse = mapper.treeToValue(mapper.readTree(statesOnCloseList[i]), MarketplaceStateOnCloseList::class.java)
        every { getAllStatesPageableCall.execute() } returns Response.success(getAllStatesPageableResponse)
      }

      val deleteSubmissionsCall = mockk<Call<ResponseBody>>()
      every { service.deleteAllSubmissions() } returns deleteSubmissionsCall
      every { service.deleteAllSubmissions(any()) } returns deleteSubmissionsCall
      val responseCode = if (submissionsDeleteRequestSuccess) HttpURLConnection.HTTP_NO_CONTENT else HttpURLConnection.HTTP_RESET
      every { deleteSubmissionsCall.execute() } answers {
        Response.success(responseCode, "empty response body".toResponseBody())
      }

      val postSubmissionCall = mockk<Call<MarketplaceSubmission>>()
      every { service.postSubmission(any(), any(), any(), any()) } returns postSubmissionCall
      val postSubmissionResponse = mapper.treeToValue(mapper.readTree(postSubmissionData), MarketplaceSubmission::class.java)
      every { postSubmissionCall.execute() } answers {
        Response.success(postSubmissionResponse)
      }

      val reportSolutionCall = mockk<Call<ResponseBody>>()
      every { service.reportSolution(any()) } returns reportSolutionCall
      val reportCommunityResponse = if (reportSolutionRequestSuccess) {
        Response.success(HttpURLConnection.HTTP_NO_CONTENT, "mock report response body".toResponseBody())
      }
      else {
        Response.error(HttpURLConnection.HTTP_NOT_FOUND, "mock report response body".toResponseBody())
      }
      every { reportSolutionCall.execute() } returns reportCommunityResponse

      if (solutionsKeyTextMap.isNotEmpty()) {
        mockkObject(MarketplaceSubmissionsConnector)

        for (key in solutionsKeyTextMap.keys) {
          val downloadLink = "downloadLink/key=$key"
          val getSolutionLinkCall = mockk<Call<ResponseBody>>()
          every { service.getSolutionDownloadLink(key) } returns getSolutionLinkCall
          every { getSolutionLinkCall.execute() } returns Response.success(
            downloadLink.toResponseBody("application/json; charset=UTF-8".toMediaType())
          )

          every {
            MarketplaceSubmissionsConnector.loadSolutionByLink(downloadLink)
          } returns solutionsKeyTextMap.getOrDefault(key, "no solution present for $key")
        }
      }
    }