Function postgres_solvable_presign_orders

crates/database/src/orders.rs:1810–1863

()

    #[tokio::test]
    #[ignore]
    async fn postgres_solvable_presign_orders() {
        let mut db = PgConnection::connect("postgresql://").await.unwrap();
        let mut db = db.begin().await.unwrap();
        crate::clear_DANGER_(&mut db).await.unwrap();

        let order = Order {
            sell_amount: 1.into(),
            buy_amount: 1.into(),
            signing_scheme: SigningScheme::PreSign,
            creation_timestamp: Utc::now(),
            ..Default::default()
        };
        insert_order(&mut db, &order).await.unwrap();

        async fn get_full_order(ex: &mut PgConnection) -> Option<FullOrder> {
            solvable_orders(ex, 0).next().await.transpose().unwrap()
        }

        async fn pre_signature_event(
            ex: &mut PgTransaction<'_>,
            block_number: i64,
            owner: Address,
            order_uid: OrderUid,
            signed: bool,
        ) {
            let events = [(
                EventIndex {
                    block_number,
                    log_index: 0,
                },
                Event::PreSignature(PreSignature {
                    owner,
                    order_uid,
                    signed,
                }),
            )];
            crate::events::append(ex, &events).await.unwrap()
        }

        // not solvable because there is no presignature event.
        assert!(get_full_order(&mut db).await.unwrap().presignature_pending);

        // solvable because once presignature event is observed.
        pre_signature_event(&mut db, 0, order.owner, order.uid, true).await;
        assert!(!get_full_order(&mut db).await.unwrap().presignature_pending);

        // not solvable because "unsigned" presignature event.
        pre_signature_event(&mut db, 1, order.owner, order.uid, false).await;
        assert!(get_full_order(&mut db).await.unwrap().presignature_pending);

        // solvable once again because of new presignature event.
        pre_signature_event(&mut db, 2, order.owner, order.uid, true).await;
        assert!(!get_full_order(&mut db).await.unwrap().presignature_pending);
    }

    #[tokio::test]
    #[ignore]