fn fn_impls()

in yaml_test_runner/src/generator.rs [180:288]

• 105 lines of code
• 5 McCabe index (conditional complexity)

    fn fn_impls(
        &self,
        general_setup_call: Tokens,
        setup_call: Option<Tokens>,
        teardown_call: Option<Tokens>,
    ) -> Vec<Option<Tokens>> {
        let mut seen_names = HashSet::new();

        self.tests
            .iter()
            .map(|test_fn| {
                let name = test_fn.name();
                let unique_name = test_fn.unique_name(&mut seen_names);
                if self.skip_test(name) {
                    info!(
                        r#"skipping "{}" in {} because it's included in skip.yml"#,
                        name,
                        self.path,
                    );
                    return None;
                }

                let fn_name = syn::Ident::from(unique_name.as_str());
                let mut body = Tokens::new();
                let mut skip : Option<String> = None;
                let mut read_response = false;

                for step in &test_fn.steps {
                    match step {
                        Step::Skip(s) => {
                            skip = if s.skip_version(self.version) {
                                let m = format!(
                                    r#"skipping "{}" in {} because version "{}" is met. {}"#,
                                    name,
                                    &self.path,
                                    s.version(),
                                    s.reason()
                                );
                                Some(m)
                            } else if s.skip_features(&self.skip.features) {
                                let m = format!(
                                    r#"skipping "{}" in {} because it needs features "{:?}" which are currently not implemented"#,
                                    name,
                                    &self.path,
                                    s.features()
                                );
                                Some(m)
                            } else {
                                None
                            }
                        }
                        Step::Do(d) => {
                            read_response = d.to_tokens(false, &mut body);
                        }
                        Step::Match(m) => {
                            read_response = Self::read_response(read_response,&mut body);
                            m.to_tokens(&mut body);
                        }
                        Step::Set(s) => {
                            read_response = Self::read_response(read_response, &mut body);
                            s.to_tokens(&mut body);
                        }
                        Step::Length(l) => {
                            read_response = Self::read_response(read_response,&mut body);
                            l.to_tokens(&mut body);
                        },
                        Step::IsTrue(t) => {
                            read_response = Self::read_response(read_response,&mut body);
                            t.to_tokens(&mut body);
                        },
                        Step::IsFalse(f) => {
                            read_response = Self::read_response(read_response, &mut body);
                            f.to_tokens(&mut body);
                        },
                        Step::Comparison(c) => {
                            read_response = Self::read_response(read_response,&mut body);
                            c.to_tokens(&mut body);
                        },
                        Step::Contains(c) => {
                            read_response = Self::read_response(read_response,&mut body);
                            c.to_tokens(&mut body);
                        },
                        Step::TransformAndSet(t) => {
                            read_response = Self::read_response(read_response,&mut body);
                            t.to_tokens(&mut body);
                        }
                    }
                }

                match skip {
                    Some(s) => {
                        info!("{}", s);
                        None
                    },
                    None => Some(quote! {
                        #[tokio::test]
                        async fn #fn_name() -> anyhow::Result<()> {
                            let client = client::get();
                            #general_setup_call
                            #setup_call
                            #body
                            #teardown_call
                            Ok(())
                        }
                    }),
                }
            })
            .collect()
    }