def test_create_minefield_should_create_a_first_turn(self):
        spy = Mock(CreateMinefieldUseCaseObserver)
        self.subject(row_index=0, column_index=1, observer=spy)

        captured_minefield_identifier = spy.did_create_minefield.call_args[1]["minefield_identifier"]
        captured_first_turn = spy.did_create_minefield.call_args[1]["first_turn"]

        fetched_turn_list = None
        fetched_minefield_identifier = None

        def did_fetch_ordererd_turns(turn_list: List[Turn], minefield_identifier: UUID):
            nonlocal fetched_turn_list
            nonlocal fetched_minefield_identifier
            fetched_turn_list = turn_list
            fetched_minefield_identifier = minefield_identifier

        self.turn_repository.fetch_ordered_turns(
            last_turn_identifier=captured_first_turn.identifier, success=did_fetch_ordererd_turns
        )

        expected_turn_list = [
            Turn(
                identifier=captured_first_turn.identifier,
                coordinate=Coordinate(row_index=0, column_index=1),
                action=TurnAction.RevealCell,
                parent_turn_identifier=None,
                minefield_identifier=captured_minefield_identifier,
            )
        ]

        assert_turn_lists_equal(fetched_turn_list, expected_turn_list, self)
        self.assertEqual(fetched_minefield_identifier, captured_minefield_identifier)
    def test_created_turns_can_be_fetched_in_the_order_they_were_created(self):
        minefield_identifier = uuid4()

        first_coordinate = Coordinate(row_index=0, column_index=0)
        turn_action = TurnAction.RevealCell
        first_turn_identifier = None

        def did_create_first_turn(turn):
            nonlocal first_turn_identifier
            first_turn_identifier = turn.identifier

        self.subject.create_turn(coordinate=first_coordinate,
                                 action=turn_action,
                                 parent_turn_identifier=None,
                                 minefield_identifier=minefield_identifier,
                                 success=did_create_first_turn)

        second_coordinate = Coordinate(row_index=0, column_index=1)
        second_turn_identifier = None

        def did_create_second_turn(turn):
            nonlocal second_turn_identifier
            second_turn_identifier = turn.identifier

        self.subject.create_turn(coordinate=second_coordinate,
                                 action=turn_action,
                                 parent_turn_identifier=first_turn_identifier,
                                 minefield_identifier=minefield_identifier,
                                 success=did_create_second_turn)
        fetched_turns = None
        fetched_minefield_identifier = None

        def did_fetch_ordered_turns(turn_list: List[Turn], minefield_identifier: UUID):
            nonlocal fetched_turns
            nonlocal fetched_minefield_identifier
            fetched_turns = turn_list
            fetched_minefield_identifier = minefield_identifier

        self.subject.fetch_ordered_turns(last_turn_identifier=second_turn_identifier,
                                         success=did_fetch_ordered_turns)

        expected_first_turn = Turn(identifier=first_turn_identifier,
                                   action=TurnAction.RevealCell,
                                   coordinate=first_coordinate,
                                   parent_turn_identifier=None,
                                   minefield_identifier=minefield_identifier)
        expected_second_turn = Turn(identifier=second_turn_identifier,
                                    action=TurnAction.RevealCell,
                                    coordinate=second_coordinate,
                                    parent_turn_identifier=first_turn_identifier,
                                    minefield_identifier=minefield_identifier)
        expected_turns = [expected_first_turn, expected_second_turn]

        assert_turn_lists_equal(turn_list=fetched_turns,
                                expected_turn_list=expected_turns,
                                test_case=self)