mocktoffel 0.1.0

easy to use mocking library with minimal boilerplate
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use std::ops::Deref;

use proc_macro::TokenStream;
use quote::quote;
use syn::{
    parse, parse_str, FnArg, ImplItem, ImplItemFn, ImplItemType, ItemImpl, ReturnType, Type,
    TypePath,
};

use crate::extract::{prepare_mock_name, ExtractName, Extracted};

pub struct MockContext {
    original_type: Box<Type>,
    mocked_extract: Extracted,
}

impl MockContext {
    pub fn new(original_type: Box<Type>) -> Self {
        let mock_name = prepare_mock_name(&original_type.extract_name());
        Self {
            original_type,
            mocked_extract: mock_name,
        }
    }

    #[allow(clippy::redundant_clone)]
    pub fn mock_impl(&self, tokens: ItemImpl) -> TokenStream {
        let original_type = tokens.self_ty.clone();
        let original_name = original_type.extract_name();
        let Extracted { name, .. } = prepare_mock_name(&original_name);

        if let Some((_, tr, _)) = tokens.trait_ {
            let functions = tokens.items.into_iter().map(|item| match item {
                ImplItem::Fn(f) => self.replace_self_from_function_with_mocks(f),
                ImplItem::Type(mut ty) => {
                    self.replace_mocks_in_associated_types(&mut ty);
                    ImplItem::Type(ty)
                }
                _ => todo!(),
            });

            let Extracted {
                name: trait_,
                generics: trait_generics,
            } = tr.extract_name();
            let impl_generics = tokens.generics.clone();

            TokenStream::from(quote! {
                impl #impl_generics #trait_ #trait_generics for #name {
                    #(#functions)*
                }
            })
        } else {
            let functions = tokens.items.into_iter().map(|item| match item {
                ImplItem::Fn(f) => self.replace_self_from_function_with_mocks(f),
                _ => unreachable!(),
            });

            let impl_generics = tokens.generics.clone();
            let generics = original_name.generics.clone();

            TokenStream::from(quote! {
                impl #impl_generics #name #generics {
                    #(#functions)*
                }
            })
        }
    }

    #[allow(clippy::explicit_deref_methods)]
    fn replace_self_from_function_with_mocks(&self, mut f: ImplItemFn) -> ImplItem {
        let visibility = f.vis;

        f.sig.inputs.iter_mut().filter_map(|arg| {
                      if let FnArg::Typed(ref mut typ) = arg && typ.ty == self.original_type && let Type::Path(ref mut p) = &mut *typ.ty {
                          Some(p)
                      } else {
                          None
                      }
              }).for_each(|p| {
                    let segments = p.path.segments.last_mut().unwrap();
                    let fn_generics = segments.arguments.clone();
                    *p = parse_str(format!("{}", self.mocked_extract.name).as_str()).unwrap();

                        let segment = p.path.segments.last_mut().unwrap();
                        segment.arguments = fn_generics;
              });

        let inputs = f.sig.inputs.iter();

        let function_name = f.sig.ident;
        let name = self.mocked_extract.name.clone();
        let original_name = self.original_type.extract_name();
        let generics = original_name.generics;
        syn::parse(match &f.sig.output {
               ReturnType::Type(_, ref p) if let Type::Path(TypePath { path: pat, .. }) = p.deref() && pat.extract_name().name == original_name.name => {
                   if pat.extract_name().name == original_name.name {
                       TokenStream::from(quote! {
                           #visibility fn #function_name (#(#inputs),*) -> #name #generics {
                               <#name>::mock_new()
                           }
                       })
                   } else {
                      TokenStream::from(quote!(f))
                   }
               },

               ReturnType::Type(_, ty) => {
                   TokenStream::from(quote!{
                       #visibility fn #function_name(#(#inputs), *) -> #ty {
                           Default::default()
                       }
                   })
               },

               ReturnType::Default => {
                   TokenStream::from(quote!{
                       #visibility fn #function_name(#(#inputs), *) {
                       }
                   })
               }
           }).unwrap()
    }

    fn replace_mocks_in_associated_types(&self, associated_type: &mut ImplItemType) {
        let Extracted { name, generics } = associated_type.ty.extract_name();
        if name == self.original_type.extract_name().name {
            let original_type = self.original_type.clone();
            let Extracted {
                name: mocked_name,
                generics: mocked_generics,
            } = prepare_mock_name(&original_type.extract_name());
            associated_type.ty =
                parse(TokenStream::from(quote! { #mocked_name #mocked_generics })).unwrap();
        }
    }
}