Merge pull request #479 from AmbireTech/channel-list-tests

Tests for GET /v5/channel/list and multichain support

Author: simzzz

adapter/src/ethereum/test_util.rs

@@ -92,16 +92,16 @@ pub static KEYSTORES: Lazy<HashMap<Address, Options>> = Lazy::new(|| {
 pub const GANACHE_URL: &str = "http://localhost:8545";
 
 // /// [`Chain`] of the locally running `ganache-cli` chain with id #1
-// pub static GANACHE_1: Lazy<Chain> = Lazy::new(|| GANACHE_INFO_1.chain.clone());
-
-// /// [`ChainInfo`] of the locally running `ganache-cli` chain with id #1
-// pub static GANACHE_INFO_1: Lazy<ChainInfo> = Lazy::new(|| {
-//     GANACHE_CONFIG
-//         .chains
-//         .get("Ganache #1")
-//         .expect("Ganache Local chain 1 not found")
-//         .clone()
-// });
+pub static GANACHE_1: Lazy<Chain> = Lazy::new(|| GANACHE_INFO_1.chain.clone());
+
+/// [`ChainInfo`] of the locally running `ganache-cli` chain with id #1
+pub static GANACHE_INFO_1: Lazy<ChainInfo> = Lazy::new(|| {
+    GANACHE_CONFIG
+        .chains
+        .get("Ganache #1")
+        .expect("Ganache Local chain 1 not found")
+        .clone()
+});
 
 /// [`Chain`] of the locally running `ganache-cli` chain with id #1337
 pub static GANACHE_1337: Lazy<Chain> = Lazy::new(|| GANACHE_INFO_1337.chain.clone());

adview-manager/serve/src/main.rs

@@ -151,63 +151,67 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     });
 
     // GET /preview/video
-    let get_preview_of_video = warp::get().and(warp::path!("preview" / "video" )).then(move || {
-        let tera = tera.clone();
+    let get_preview_of_video = warp::get()
+        .and(warp::path!("preview" / "video"))
+        .then(move || {
+            let tera = tera.clone();
 
-        async move {
-            let whitelisted_tokens = vec!["0x6B175474E89094C44Da98b954EedeAC495271d0F"
-                .parse()
-                .expect("Valid token Address")];
-            let disabled_video = false;
-            let publisher_addr = "0x0000000000000000626f62627973686d75726461"
-                .parse()
-                .unwrap();
-
-            let options = Options {
-                market_url: "http://placeholder.com".parse().unwrap(),
-                market_slot: DUMMY_IPFS[0],
-                publisher_addr,
-                // All passed tokens must be of the same price and decimals, so that the amounts can be accurately compared
-                whitelisted_tokens,
-                size: Some(Size::new(728, 90)),
-                // TODO: Check this value
-                navigator_language: Some("bg".into()),
-                /// Defaulted
-                disabled_video,
-                disabled_sticky: false,
-            };
-
-            // legacy_728x90
-            let video_ad_unit = adex_primitives::supermarket::units_for_slot::response::AdUnit {
-                /// Same as `ipfs`
-                id: "QmShJ6tsJ7LHLiYGX4EAmPyCPWJuCnvm6AKjweQPnw9qfh"
+            async move {
+                let whitelisted_tokens = vec!["0x6B175474E89094C44Da98b954EedeAC495271d0F"
                     .parse()
-                    .expect("Valid IPFS"),
-                media_url: "ipfs://Qmevmms1AZgYXS27A9ghSjHn4DSaHMfgYcD2SoGW14RYGy".to_string(),
-                media_mime: "video/mp4".to_string(),
-                target_url: "https://www.stremio.com/downloads".to_string(),
-            };
-
-            let video_html = get_unit_html_with_events(
-                &options,
-                &video_ad_unit,
-                "localhost",
-                DUMMY_CAMPAIGN.id,
-                &DUMMY_CAMPAIGN.validators,
-                false,
-            );
-
-            // let video_html = get_unit_html_with_events(&options, );
-            let html = {
-                let mut context = Context::new();
-                context.insert("ad_code", &video_html);
+                    .expect("Valid token Address")];
+                let disabled_video = false;
+                let publisher_addr = "0x0000000000000000626f62627973686d75726461"
+                    .parse()
+                    .unwrap();
+
+                let options = Options {
+                    market_url: "http://placeholder.com".parse().unwrap(),
+                    market_slot: DUMMY_IPFS[0],
+                    publisher_addr,
+                    // All passed tokens must be of the same price and decimals, so that the amounts can be accurately compared
+                    whitelisted_tokens,
+                    size: Some(Size::new(728, 90)),
+                    // TODO: Check this value
+                    navigator_language: Some("bg".into()),
+                    /// Defaulted
+                    disabled_video,
+                    disabled_sticky: false,
+                };
 
-                tera.render("ad.html", &context).expect("Should render")
-            };
+                // legacy_728x90
+                let video_ad_unit =
+                    adex_primitives::supermarket::units_for_slot::response::AdUnit {
+                        /// Same as `ipfs`
+                        id: "QmShJ6tsJ7LHLiYGX4EAmPyCPWJuCnvm6AKjweQPnw9qfh"
+                            .parse()
+                            .expect("Valid IPFS"),
+                        media_url: "ipfs://Qmevmms1AZgYXS27A9ghSjHn4DSaHMfgYcD2SoGW14RYGy"
+                            .to_string(),
+                        media_mime: "video/mp4".to_string(),
+                        target_url: "https://www.stremio.com/downloads".to_string(),
+                    };
+
+                let video_html = get_unit_html_with_events(
+                    &options,
+                    &video_ad_unit,
+                    "localhost",
+                    DUMMY_CAMPAIGN.id,
+                    &DUMMY_CAMPAIGN.validators,
+                    false,
+                );
+
+                // let video_html = get_unit_html_with_events(&options, );
+                let html = {
+                    let mut context = Context::new();
+                    context.insert("ad_code", &video_html);
+
+                    tera.render("ad.html", &context).expect("Should render")
+                };
 
-            warp::reply::html(html)
-        }
-    });
+                warp::reply::html(html)
+            }
+        });
 
     warp::serve(get_ad.or(get_preview_of_video))
         .run(([127, 0, 0, 1], 3030))

docs/config/ganache.toml

@@ -67,3 +67,23 @@ sweeper = '0x7dD57C0324284102A757153E18F2Cb1ACdB7d2bD'
     # min_validator_fee = 1 * 10^-6 = 0.000_001
     min_validator_fee = '1000000000000'
 
+
+[chain."Ganache #1"]
+# Ganache default chain id for testing
+chain_id = 1
+rpc = 'http://localhost:8546'
+# Ganache Snapshot address
+outpace = '0x0000000000000000000000000000000000000001'
+# Ganache Snapshot address
+sweeper = '0x0000000000000000000000000000000000000001'
+
+    [chain."Ganache #1".token."Mocked TOKEN 2"]
+    address = '0x0000000000000000000000000000000000000001' # checked
+    precision = 18
+    # Minimum token units for the Create2 deposits to count
+    # 1 * 10^18 = 1.0000 TOKEN
+    min_token_units_for_deposit = '1000000000000000000'
+    # multiplier = 10^12 - 10^18 (token precision) = 10^-6
+    # min_validator_fee = 1 * 10^-6 = 0.000_001
+    min_validator_fee = '1000000000000'
+

sentry/src/routes/channel.rs

@@ -668,10 +668,18 @@ mod test {
     use crate::db::{insert_campaign, insert_channel};
     use crate::test_util::setup_dummy_app;
     use crate::CampaignRemaining;
+    use adapter::{
+        ethereum::test_util::{GANACHE_INFO_1, GANACHE_INFO_1337},
+        primitives::Deposit as AdapterDeposit,
+    };
     use hyper::StatusCode;
     use primitives::{
-        test_util::{ADVERTISER, CREATOR, GUARDIAN, PUBLISHER, PUBLISHER_2},
-        test_util::{DUMMY_CAMPAIGN, IDS},
+        channel::Nonce,
+        sentry::channel_list::ChannelListResponse,
+        test_util::{
+            ADVERTISER, CREATOR, DUMMY_CAMPAIGN, FOLLOWER, GUARDIAN, IDS, LEADER, LEADER_2,
+            PUBLISHER, PUBLISHER_2,
+        },
         BigNum, Deposit, UnifiedMap, ValidatorId,
     };
 
@@ -690,7 +698,7 @@ mod test {
         };
 
         let precision: u8 = channel_context.token.precision.into();
-        let deposit = Deposit {
+        let deposit = AdapterDeposit {
             total: BigNum::from_str("100000000000000000000").expect("should convert"), // 100 DAI
             still_on_create2: BigNum::from_str("1000000000000000000").expect("should convert"), // 1 DAI
         };
@@ -731,7 +739,7 @@ mod test {
             .expect("should return a spendable");
         assert!(spendable.is_some());
 
-        let updated_deposit = Deposit {
+        let updated_deposit = AdapterDeposit {
             total: BigNum::from_str("110000000000000000000").expect("should convert"), // 110 DAI
             still_on_create2: BigNum::from_str("1100000000000000000").expect("should convert"), // 1.1 DAI
         };
@@ -771,6 +779,14 @@ mod test {
         accounting_response
     }
 
+    async fn res_to_channel_list_response(res: Response<Body>) -> ChannelListResponse {
+        let json = hyper::body::to_bytes(res.into_body())
+            .await
+            .expect("Should get json");
+
+        serde_json::from_slice(&json).expect("Should deserialize ChannelListResponse")
+    }
+
     #[tokio::test]
     async fn get_accountings_for_channel() {
         let app = setup_dummy_app().await;
@@ -976,6 +992,149 @@ mod test {
         );
     }
 
+    #[tokio::test]
+    async fn get_channels_list() {
+        let mut app = setup_dummy_app().await;
+        app.config.channels_find_limit = 2;
+
+        let channel = Channel {
+            leader: IDS[&LEADER],
+            follower: IDS[&FOLLOWER],
+            guardian: *GUARDIAN,
+            token: GANACHE_INFO_1337.tokens["Mocked TOKEN"].address,
+            nonce: Nonce::from(987_654_321_u32),
+        };
+        insert_channel(&app.pool, channel)
+            .await
+            .expect("should insert");
+        let channel_other_token = Channel {
+            leader: IDS[&LEADER],
+            follower: IDS[&FOLLOWER],
+            guardian: *GUARDIAN,
+            token: GANACHE_INFO_1.tokens["Mocked TOKEN 2"].address,
+            nonce: Nonce::from(987_654_322_u32),
+        };
+        insert_channel(&app.pool, channel_other_token)
+            .await
+            .expect("should insert");
+
+        let channel_other_leader = Channel {
+            leader: IDS[&LEADER_2],
+            follower: IDS[&FOLLOWER],
+            guardian: *GUARDIAN,
+            token: GANACHE_INFO_1337.tokens["Mocked TOKEN"].address,
+            nonce: Nonce::from(987_654_323_u32),
+        };
+        insert_channel(&app.pool, channel_other_leader)
+            .await
+            .expect("should insert");
+
+        let build_request = |query: ChannelListQuery| {
+            let query = serde_urlencoded::to_string(query).expect("should parse query");
+            Request::builder()
+                .uri(format!("http://127.0.0.1/v5/channel/list?{}", query))
+                .extension(DUMMY_CAMPAIGN.channel.clone())
+                .body(Body::empty())
+                .expect("Should build Request")
+        };
+
+        // Test query page - page 0, page 1
+        {
+            let query = ChannelListQuery {
+                page: 0,
+                validator: None,
+            };
+            let res = channel_list(build_request(query), &app)
+                .await
+                .expect("should get channels");
+            let channels_list = res_to_channel_list_response(res).await;
+
+            assert_eq!(
+                channels_list.channels,
+                vec![channel, channel_other_token],
+                "The channels should be listed by ascending order of their creation"
+            );
+            assert_eq!(
+                channels_list.pagination.total_pages, 2,
+                "There should be 2 pages in total"
+            );
+
+            let query = ChannelListQuery {
+                page: 1,
+                validator: None,
+            };
+            let res = channel_list(build_request(query), &app)
+                .await
+                .expect("should get channels");
+            let channels_list = res_to_channel_list_response(res).await;
+            assert_eq!(
+                channels_list.channels,
+                vec![channel_other_leader],
+                "The channels should be listed by ascending order of their creation"
+            );
+        }
+
+        // Test query validator - query with validator ID
+        {
+            let query = ChannelListQuery {
+                page: 0,
+                validator: Some(IDS[&LEADER_2]),
+            };
+            let res = channel_list(build_request(query), &app)
+                .await
+                .expect("should get channels");
+            let channels_list = res_to_channel_list_response(res).await;
+            assert_eq!(
+                channels_list.channels,
+                vec![channel_other_leader],
+                "Response returns the correct channel"
+            );
+            assert_eq!(
+                channels_list.pagination.total_pages, 1,
+                "There should be 1 page in total"
+            );
+        }
+        // Test query with both pagination and validator by querying for the follower validator
+        {
+            let query = ChannelListQuery {
+                page: 0,
+                validator: Some(IDS[&FOLLOWER]),
+            };
+            let res = channel_list(build_request(query), &app)
+                .await
+                .expect("should get channels");
+            let channels_list = res_to_channel_list_response(res).await;
+
+            assert_eq!(
+                channels_list.pagination.total_pages, 2,
+                "There should be 2 pages in total"
+            );
+            assert_eq!(
+                channels_list.channels,
+                vec![channel, channel_other_token],
+                "The channels should be listed by ascending order of their creation"
+            );
+
+            let query = ChannelListQuery {
+                page: 1,
+                validator: Some(IDS[&FOLLOWER]),
+            };
+            let res = channel_list(build_request(query), &app)
+                .await
+                .expect("should get channels");
+            let channels_list = res_to_channel_list_response(res).await;
+            assert_eq!(
+                channels_list.channels,
+                vec![channel_other_leader],
+                "The channels should be listed by ascending order of their creation"
+            );
+            assert_eq!(
+                channels_list.pagination.total_pages, 2,
+                "There should be 2 pages in total"
+            );
+        }
+    }
+
     #[tokio::test]
     async fn payouts_for_earners_test() {
         let app = setup_dummy_app().await;