sapling/blobrepo_utils/test/main.rs

// Copyright (c) 2018-present, Facebook, Inc.
// All Rights Reserved.
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.

#![deny(warnings)]

extern crate futures;
#[macro_use]
extern crate slog;

extern crate async_unit;
extern crate slog_glog_fmt;

extern crate blobrepo_utils;
extern crate context;
extern crate mercurial_types;

extern crate fixtures;
extern crate tokio;

use fixtures::*;

// An extra level of nesting is required to avoid clashes between crate and module names.
mod test {
    macro_rules! test_verify {
        ($repo:ident) => {
            mod $repo {
                use std::collections::HashSet;

                use futures::{Future, Stream};
                use slog::{Drain, Level, Logger};

                use async_unit;
                use slog_glog_fmt::default_drain as glog_drain;

                use blobrepo_utils::{BonsaiMFVerify, BonsaiMFVerifyResult};
                use context::CoreContext;
                use mercurial_types::HgChangesetId;

                use $repo;

                #[test]
                fn test() {
                    async_unit::tokio_unit_test(|| {
                        let ctx = CoreContext::test_mock();
                        let drain = glog_drain().filter_level(Level::Debug).fuse();
                        let logger = Logger::root(drain, o![]);

                        let repo = $repo::getrepo(Some(logger.clone()));
                        let heads = repo.get_heads_maybe_stale(ctx.clone())
                            .collect()
                            .map(|heads| heads.into_iter().map(HgChangesetId::new));

                        let verify = BonsaiMFVerify {
                            ctx,
                            logger,
                            repo,
                            follow_limit: 1024,
                            ignores: HashSet::new(),
                            broken_merges_before: None,
                            debug_bonsai_diff: false,
                        };

                        let results = heads
                            .map_err(|err| panic!("cannot get the heads {}", err))
                            .and_then(|heads| verify.verify(heads).collect());
                        tokio::spawn(
                            results
                                .and_then(|results| {
                                    let diffs = results.into_iter().filter_map(|(res, meta)| {
                                        match res {
                                            BonsaiMFVerifyResult::Invalid(difference) => {
                                                let cs_id = meta.changeset_id;
                                                Some(difference
                                                    .changes()
                                                    .collect()
                                                    .map(move |changes| (cs_id, changes)))
                                            }
                                            _ => None,
                                        }
                                    });

                                    futures::future::join_all(diffs)
                                })
                                .map(|diffs| {
                                    let mut failed = false;
                                    let mut desc = Vec::new();
                                    for (changeset_id, changes) in diffs {
                                        failed = true;
                                        desc.push(format!(
                                            "*** Inconsistent roundtrip for {}",
                                            changeset_id,
                                        ));
                                        for changed_entry in changes {
                                            desc.push(format!("  - Changed entry: {:?}", changed_entry));
                                        }
                                        desc.push("".to_string());
                                    }
                                    let desc = desc.join("\n");
                                    if failed {
                                        panic!("Inconsistencies detected, roundtrip test failed\n\n{}", desc);
                                    }
                                })
                                .map_err(|err| {
                                    panic!("verify error {}", err);
                                })
                        );
                    })
                }
            }
        }
    }

    test_verify!(branch_even);
    test_verify!(branch_uneven);
    test_verify!(branch_wide);
    test_verify!(linear);
    test_verify!(merge_even);
    test_verify!(merge_uneven);
    test_verify!(unshared_merge_even);
    test_verify!(unshared_merge_uneven);
}