Function check_vote_success

src/processor.rs:1344–1394

()

    #[tokio::test]
    async fn check_vote_success() {
        let mut db = MockDB::new();
        db.expect_get_open_vote()
            .with(eq(REPOFN), eq(ISSUE_NUM))
            .times(1)
            .returning(|_, _| Box::pin(future::ready(Ok(Some(setup_test_vote())))));
        db.expect_update_vote_last_check()
            .with(eq(Uuid::parse_str(VOTE_ID).unwrap()))
            .times(1)
            .returning(|_| Box::pin(future::ready(Ok(()))));
        let mut gh = MockGH::new();
        gh.expect_get_comment_reactions()
            .with(eq(INST_ID), eq(ORG), eq(REPO), eq(COMMENT_ID))
            .times(1)
            .returning(|_, _, _, _| {
                Box::pin(future::ready(Ok(vec![Reaction {
                    user: User {
                        login: USER1.to_string(),
                    },
                    content: REACTION_IN_FAVOR.to_string(),
                    created_at: TIMESTAMP.to_string(),
                }])))
            });
        gh.expect_get_allowed_voters()
            .withf(|inst_id, cfg, owner, repo, org| {
                *inst_id == INST_ID
                    && *cfg == setup_test_vote().cfg
                    && owner == ORG
                    && repo == REPO
                    && *org == Some(ORG.to_string()).as_ref()
            })
            .times(1)
            .returning(|_, _, _, _, _| Box::pin(future::ready(Ok(vec![USER1.to_string()]))));
        gh.expect_post_comment()
            .withf(|inst_id, owner, repo, issue_number, body| {
                let results = setup_test_vote_results();
                let expected_body = tmpl::VoteStatus::new(&results).render().unwrap();
                *inst_id == INST_ID
                    && owner == ORG
                    && repo == REPO
                    && *issue_number == ISSUE_NUM
                    && body == expected_body.as_str()
            })
            .times(1)
            .returning(|_, _, _, _, _| Box::pin(future::ready(Ok(COMMENT_ID))));

        let (_, cmds_rx) = async_channel::unbounded();
        let event = setup_test_pr_event();
        let cmds_handler = CommandsHandler::new(Arc::new(db), Arc::new(gh), cmds_rx);
        cmds_handler.check_vote(&CheckVoteInput::new(&Event::PullRequest(event))).await.unwrap();
    }

    #[tokio::test]
    #[should_panic(expected = "error closing finished vote")]