Example #1
0
def create_proposals(count, category, stage, with_comments=False):
    user = User.query.filter_by().first()
    for i in range(count):
        target = "123.456"
        p = Proposal.create(
            stage=stage,
            status=ProposalStatus.LIVE,
            title=f'Fake Proposal #{i} {category} {stage}',
            content=f'My fake proposal content, numero {i}',
            brief=f'This is proposal {i} generated by e2e testing',
            category=category,
            target=target,
            payout_address="fake123",
            deadline_duration=100)
        p.date_published = datetime.now()
        p.team.append(user)
        db.session.add(p)
        db.session.flush()
        num_ms = randint(1, 9)
        for j in range(num_ms):
            m = Milestone(
                title=f'Fake MS {j}',
                content=
                f'Fake milestone #{j} on fake proposal #{i} {category} {stage}!',
                date_estimated=datetime.now(),
                payout_amount=str(float(target) / num_ms),
                immediate_payout=j == 0,
                proposal_id=p.id,
                index=j)
            db.session.add(m)
        # limit comment creation as it is slow
        if i == 0 and with_comments:
            for j in range(31):
                c = Comment(
                    proposal_id=p.id,
                    user_id=user.id,
                    parent_comment_id=None,
                    content=
                    f'Fake comment #{j} on fake proposal #{i} {category} {stage}!'
                )
                db.session.add(c)
        if stage == ProposalStage.FUNDING_REQUIRED:
            stake = p.create_contribution('1', None, True)
            stake.confirm('fakestaketxid', '1')
            db.session.add(stake)
            db.session.flush()
            fund = p.create_contribution('100', None, False)
            fund.confirm('fakefundtxid0', '100')
            db.session.add(fund)
            db.session.flush()
            p.status = ProposalStatus.LIVE
            db.session.add(p)
            db.session.flush()
    def test_proposal_pruning_noops(self):
        # ensure all proposal noop states work as expected

        def status(p):
            p.status = ProposalStatus.LIVE

        def title(p):
            p.title = 'title'

        def brief(p):
            p.brief = 'brief'

        def content(p):
            p.content = 'content'

        def category(p):
            p.category = Category.DEV_TOOL

        def target(p):
            p.target = '100'

        def payout_address(p):
            p.payout_address = 'address'

        def milestones(p):
            Milestone.make(milestones_data, p)

        modifiers = [
            status, title, brief, content, category, target, payout_address,
            milestones
        ]

        for modifier in modifiers:
            proposal = Proposal.create(status=ProposalStatus.DRAFT)
            proposal_id = proposal.id
            modifier(proposal)

            db.session.add(proposal)
            db.session.commit()

            blob = {
                "proposal_id": proposal_id,
            }

            task = Task(job_type=PruneDraft.JOB_TYPE,
                        blob=blob,
                        execute_after=datetime.now())

            PruneDraft.process_task(task)

            proposal = Proposal.query.get(proposal_id)
            self.assertIsNotNone(proposal)
Example #3
0
    def setUp(self):
        super().setUp()
        self._proposal = Proposal.create(
            status=ProposalStatus.DRAFT,
            title=test_proposal["title"],
            content=test_proposal["content"],
            brief=test_proposal["brief"],
            category=test_proposal["category"],
            target=test_proposal["target"],
        )
        self._proposal.team.append(self.user)
        db.session.add(self._proposal)
        db.session.flush()

        milestones = [
            {
                "title": "Milestone 1",
                "content": "Content 1",
                "date_estimated": (datetime.now() + timedelta(days=364)).timestamp(),  # random unix time in the future
                "payout_amount": 2,
                "immediate_payout": True
            },
            {
                "title": "Milestone 2",
                "content": "Content 2",
                "date_estimated": (datetime.now() + timedelta(days=365)).timestamp(),  # random unix time in the future
                "payout_amount": 3,
                "immediate_payout": False
            }
        ]

        Milestone.make(milestones, self._proposal)

        self._other_proposal = Proposal.create(status=ProposalStatus.DRAFT)
        self._other_proposal.team.append(self.other_user)
        db.session.add(self._other_proposal)
        db.session.commit()
        self._proposal_id = self._proposal.id
        self._other_proposal_id = self._other_proposal.id
Example #4
0
    def setUp(self):
        super().setUp()
        self._proposal = Proposal.create(
            status=ProposalStatus.DRAFT,
            title=test_proposal["title"],
            content=test_proposal["content"],
            brief=test_proposal["brief"],
            category=test_proposal["category"],
            target=test_proposal["target"],
            payout_address=test_proposal["payoutAddress"],
            deadline_duration=test_proposal["deadlineDuration"])
        self._proposal.team.append(self.user)
        db.session.add(self._proposal)
        db.session.flush()

        milestones = [{
            "title": "Milestone 1",
            "content": "Content 1",
            "days_estimated": "30",
            "payout_percent": 50,
            "immediate_payout": True
        }, {
            "title": "Milestone 2",
            "content": "Content 2",
            "days_estimated": "20",
            "payout_percent": 50,
            "immediate_payout": False
        }]

        Milestone.make(milestones, self._proposal)

        self._other_proposal = Proposal.create(status=ProposalStatus.DRAFT)
        self._other_proposal.team.append(self.other_user)
        db.session.add(self._other_proposal)
        db.session.commit()
        self._proposal_id = self._proposal.id
        self._other_proposal_id = self._other_proposal.id
    def test_milestone_deadline_noops(self, mock_send_email):
        # make sure all milestone deadline noop states work as expected

        def proposal_delete(p, m):
            db.session.delete(p)

        def proposal_status(p, m):
            p.status = ProposalStatus.DELETED
            db.session.add(p)

        def proposal_stage(p, m):
            p.stage = ProposalStage.CANCELED
            db.session.add(p)

        def milestone_delete(p, m):
            db.session.delete(m)

        def milestone_date_requested(p, m):
            m.date_requested = datetime.now()
            db.session.add(m)

        def update_posted(p, m):
            # login and post proposal update
            self.login_default_user()
            resp = self.app.post("/api/v1/proposals/{}/updates".format(
                proposal.id),
                                 data=json.dumps(test_update),
                                 content_type='application/json')
            self.assertStatus(resp, 201)

        modifiers = [
            proposal_delete, proposal_status, proposal_stage, milestone_delete,
            milestone_date_requested, update_posted
        ]

        for modifier in modifiers:
            # make proposal and milestone
            proposal = Proposal.create(status=ProposalStatus.LIVE)
            proposal.arbiter.user = self.other_user
            proposal.team.append(self.user)
            proposal_id = proposal.id
            Milestone.make(milestones_data, proposal)

            db.session.add(proposal)
            db.session.commit()

            # grab update count for blob
            update_count = len(
                ProposalUpdate.query.filter_by(proposal_id=proposal_id).all())

            # run modifications to trigger noop
            proposal = Proposal.query.get(proposal_id)
            milestone = proposal.milestones[0]
            milestone_id = milestone.id
            modifier(proposal, milestone)
            db.session.commit()

            # make task
            blob = {
                "proposal_id": proposal_id,
                "milestone_id": milestone_id,
                "update_count": update_count
            }
            task = Task(job_type=MilestoneDeadline.JOB_TYPE,
                        blob=blob,
                        execute_after=datetime.now())

            # run task
            MilestoneDeadline.process_task(task)

            # check to make sure noop occurred
            mock_send_email.assert_not_called()