fun testUseCase1()

in src/integrationTests/kotlin/UseCase1Test.kt [34:117]
62 lines of code
1 McCabe index (conditional complexity)

    fun testUseCase1() {
        runBlocking(Dispatchers.EDT) {
            // this opens the editor tab, and initializes everything
            openAndInitializePlugin()

            val modelService = project.service<ModelService>()

            // this selects the last commit and sets it up to be dropped
            val commitToDrop = modelService.branchInfo.currentCommits[0]
            assertThat(commitToDrop.commit.subject).isEqualTo("my final commit")

            modelService.selectSingleCommit(commitToDrop, modelService.branchInfo)

            val dropAction = DropAction()
            val dropTestEvent = createTestEvent(dropAction)
            dropAction.update(dropTestEvent)
            assertThat(dropTestEvent.presentation.isEnabled).isTrue()

            dropAction.actionPerformed(dropTestEvent)

            val fixupCommit = modelService.branchInfo.currentCommits[1]
            modelService.selectSingleCommit(fixupCommit, modelService.branchInfo)

            val fixupAction = FixupAction()
            val fixupTestEvent = createTestEvent(fixupAction)
            fixupAction.update(fixupTestEvent)
            assertThat(fixupTestEvent.presentation.isEnabled).isTrue()

            fixupAction.actionPerformed(fixupTestEvent)

            val parentOfFixedUpCommit = modelService.branchInfo.currentCommits[1]
            modelService.selectSingleCommit(parentOfFixedUpCommit, modelService.branchInfo)

            val pickAction = PickAction()
            val pickTestEvent = createTestEvent(pickAction)
            pickAction.update(pickTestEvent)
            assertThat(pickTestEvent.presentation.isEnabled).isTrue()

            pickAction.actionPerformed(pickTestEvent)
            assertThat(modelService.branchInfo.currentCommits.size).isEqualTo(4)

            val undoAction = UndoAction()
            val undoTestEvent = createTestEvent(undoAction)
            undoAction.actionPerformed(undoTestEvent)

            assertThat(modelService.branchInfo.currentCommits.size).isEqualTo(3)

            val redoAction = RedoAction()
            val redoTestEvent = createTestEvent(redoAction)
            redoAction.actionPerformed(redoTestEvent)

            assertThat(modelService.branchInfo.currentCommits.size).isEqualTo(4)

            val reorderCommit = modelService.branchInfo.currentCommits[1]
            modelService.selectSingleCommit(reorderCommit, modelService.branchInfo)
            val keyboardShortcut = BranchNavigationListener(project)
            keyboardShortcut.altDown()
            keyboardShortcut.altDown()

            assertThat(
                modelService.branchInfo.currentCommits.map {
                    it.commit.subject
                },
            ).isEqualTo(listOf("my final commit", "code quality", "first", "i love testing"))

            val rebaseAction = StartRebaseAction()
            val rebaseEvent = createTestEvent(rebaseAction)
            rebaseAction.actionPerformed(rebaseEvent)

            Awaitility.await()
                .alias("3 commits left for drop")
                .pollInSameThread()
                .atMost(20000, TimeUnit.MILLISECONDS)
                .pollDelay(50, TimeUnit.MILLISECONDS)
                .until {
                    gitCommitsCountEquals(3)
                }
            var remainingCommitMessages = repository.getAllCommitMessages()
            remainingCommitMessages = remainingCommitMessages.filter { it != "initial" }

            assertThat(remainingCommitMessages.contains("my final commit")).isFalse()
            assertThat(remainingCommitMessages).isEqualTo(listOf("code quality", "first", "i love testing"))
        }
    }