sabi/data_src/
mod.rs

1// Copyright (C) 2024-2026 Takayuki Sato. All Rights Reserved.
2// This program is free software under MIT License.
3// See the file LICENSE in this distribution for more details.
4
5mod global_setup;
6
7pub(crate) use global_setup::{
8    copy_global_data_srcs_to_map, create_data_conn_from_global_data_src,
9};
10pub use global_setup::{create_static_data_src_container, setup, setup_with_order, uses};
11
12use crate::{
13    AsyncGroup, DataConn, DataConnContainer, DataSrc, DataSrcContainer, DataSrcManager, ErrEntry,
14    SendSyncNonNull,
15};
16
17use std::collections::HashMap;
18use std::sync::Arc;
19use std::{any, mem, ptr};
20
21/// An enum type representing the reasons for errors that can occur within [`DataSrc`] operations.
22#[derive(Debug)]
23pub enum DataSrcError {
24    /// Indicates a failure to register a global data source.
25    /// This can happen if the global data source manager is in an invalid state.
26    FailToRegisterGlobalDataSrc {
27        /// The name of the data source that failed to register.
28        name: Arc<str>,
29    },
30
31    /// Indicates a failure during the setup process of one or more global data sources.
32    /// Contains a vector of data source names and their corresponding errors.
33    FailToSetupGlobalDataSrcs {
34        /// The vector contains errors that occurred in each [`DataSrc`] object.
35        errors: Vec<ErrEntry>,
36    },
37
38    /// Indicates that a setup process for global data sources is currently ongoing.
39    DuringSetupGlobalDataSrcs,
40
41    /// Indicates that global data sources have already been set up.
42    AlreadySetupGlobalDataSrcs,
43
44    /// Indicates a failure to cast a retrieved [`DataConn`] to the expected type.
45    FailToCastDataConn {
46        /// The name of the data connection that failed to cast.
47        name: Arc<str>,
48
49        /// The type name to which the [`DataConn`] attempted to cast.
50        target_type: &'static str,
51    },
52
53    /// Indicates a failure to create a [`DataConn`] object from its [`DataSrc`].
54    FailToCreateDataConn {
55        /// The name of the data source that failed to be created.
56        name: Arc<str>,
57
58        /// The type name of the [`DataConn`] that failed to be created.
59        data_conn_type: &'static str,
60    },
61
62    /// Indicates that no [`DataSrc`] was found to create a [`DataConn`] for the specified name
63    /// and type.
64    NotFoundDataSrcToCreateDataConn {
65        /// The name of the data source that could not be found.
66        name: Arc<str>,
67
68        /// The type name of the [`DataConn`] that was requested.
69        data_conn_type: &'static str,
70    },
71}
72
73impl<S, C> DataSrcContainer<S, C>
74where
75    S: DataSrc<C>,
76    C: DataConn + 'static,
77{
78    pub(crate) fn new(name: impl Into<Arc<str>>, data_src: S, local: bool) -> Self {
79        Self {
80            drop_fn: drop_data_src::<S, C>,
81            setup_fn: setup_data_src::<S, C>,
82            close_fn: close_data_src::<S, C>,
83            create_data_conn_fn: create_data_conn::<S, C>,
84            is_data_conn_fn: is_data_conn::<C>,
85
86            local,
87            name: name.into(),
88            data_src,
89        }
90    }
91}
92
93fn drop_data_src<S, C>(ptr: *const DataSrcContainer)
94where
95    S: DataSrc<C>,
96    C: DataConn + 'static,
97{
98    let typed_ptr = ptr as *mut DataSrcContainer<S, C>;
99    drop(unsafe { Box::from_raw(typed_ptr) });
100}
101
102fn setup_data_src<S, C>(ptr: *const DataSrcContainer, ag: &mut AsyncGroup) -> errs::Result<()>
103where
104    S: DataSrc<C>,
105    C: DataConn + 'static,
106{
107    let typed_ptr = ptr as *mut DataSrcContainer<S, C>;
108    unsafe { (*typed_ptr).data_src.setup(ag) }
109}
110
111fn close_data_src<S, C>(ptr: *const DataSrcContainer)
112where
113    S: DataSrc<C>,
114    C: DataConn + 'static,
115{
116    let typed_ptr = ptr as *mut DataSrcContainer<S, C>;
117    unsafe { (*typed_ptr).data_src.close() };
118}
119
120fn create_data_conn<S, C>(ptr: *const DataSrcContainer) -> errs::Result<Box<DataConnContainer<C>>>
121where
122    S: DataSrc<C>,
123    C: DataConn + 'static,
124{
125    let typed_ptr = ptr as *mut DataSrcContainer<S, C>;
126    let conn: Box<C> = unsafe { (*typed_ptr).data_src.create_data_conn() }?;
127    let name = unsafe { &(*typed_ptr).name };
128    Ok(Box::new(DataConnContainer::<C>::new(
129        name.to_string(),
130        conn,
131    )))
132}
133
134fn is_data_conn<C>(type_id: any::TypeId) -> bool
135where
136    C: DataConn + 'static,
137{
138    any::TypeId::of::<C>() == type_id
139}
140
141impl DataSrcManager {
142    pub(crate) const fn new(local: bool) -> Self {
143        Self {
144            vec_unready: Vec::new(),
145            vec_ready: Vec::new(),
146            local,
147        }
148    }
149
150    pub(crate) fn prepend(&mut self, vec: Vec<SendSyncNonNull<DataSrcContainer>>) {
151        self.vec_unready.splice(0..0, vec);
152    }
153
154    pub(crate) fn add<S, C>(&mut self, name: impl Into<Arc<str>>, ds: S)
155    where
156        S: DataSrc<C>,
157        C: DataConn + 'static,
158    {
159        let boxed = Box::new(DataSrcContainer::<S, C>::new(name, ds, self.local));
160        let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
161        self.vec_unready.push(SendSyncNonNull::new(ptr));
162    }
163
164    pub(crate) fn remove(&mut self, name: impl AsRef<str>) {
165        let extracted_vec: Vec<_> = self
166            .vec_ready
167            .extract_if(.., |ssnnptr| {
168                unsafe { &(*ssnnptr.non_null_ptr.as_ptr()).name }.as_ref() == name.as_ref()
169            })
170            .collect();
171
172        for ssnnptr in extracted_vec.iter().rev() {
173            let ptr = ssnnptr.non_null_ptr.as_ptr();
174            let close_fn = unsafe { (*ptr).close_fn };
175            let drop_fn = unsafe { (*ptr).drop_fn };
176            close_fn(ptr);
177            drop_fn(ptr);
178        }
179
180        let extracted_vec: Vec<_> = self
181            .vec_unready
182            .extract_if(.., |ssnnptr| {
183                unsafe { &(*ssnnptr.non_null_ptr.as_ptr()).name }.as_ref() == name.as_ref()
184            })
185            .collect();
186
187        for ssnnptr in extracted_vec.iter().rev() {
188            let ptr = ssnnptr.non_null_ptr.as_ptr();
189            let drop_fn = unsafe { (*ptr).drop_fn };
190            drop_fn(ptr);
191        }
192    }
193
194    pub(crate) fn close(&mut self) {
195        let vec = mem::take(&mut self.vec_ready);
196        for ssnnptr in vec.into_iter().rev() {
197            let ptr = ssnnptr.non_null_ptr.as_ptr();
198            let close_fn = unsafe { (*ptr).close_fn };
199            let drop_fn = unsafe { (*ptr).drop_fn };
200            close_fn(ptr);
201            drop_fn(ptr);
202        }
203        let vec = mem::take(&mut self.vec_unready);
204        for ssnnptr in vec.into_iter().rev() {
205            let ptr = ssnnptr.non_null_ptr.as_ptr();
206            let drop_fn = unsafe { (*ptr).drop_fn };
207            drop_fn(ptr);
208        }
209    }
210
211    pub(crate) fn setup(&mut self, errors: &mut Vec<ErrEntry>) {
212        if self.vec_unready.is_empty() {
213            return;
214        }
215
216        let mut ag = AsyncGroup::new();
217        for (i, ssnnptr) in self.vec_unready.iter().enumerate() {
218            let ptr = ssnnptr.non_null_ptr.as_ptr();
219            let setup_fn = unsafe { (*ptr).setup_fn };
220            let name = unsafe { &(*ptr).name };
221            ag._index = i;
222            ag._name = name.clone();
223            if let Err(err) = setup_fn(ptr, &mut ag) {
224                errors.push(ErrEntry {
225                    index: i,
226                    name: name.clone(),
227                    err,
228                });
229                break;
230            }
231        }
232        let n_done = ag._index;
233        ag.join_and_collect_errors(errors);
234
235        if errors.is_empty() {
236            self.vec_ready.append(&mut self.vec_unready);
237        } else {
238            for ssnnptr in self.vec_unready[0..n_done].iter().rev() {
239                let ptr = ssnnptr.non_null_ptr.as_ptr();
240                let close_fn = unsafe { (*ptr).close_fn };
241                close_fn(ptr);
242            }
243        }
244    }
245
246    pub(crate) fn setup_with_order(&mut self, names: &[&str], errors: &mut Vec<ErrEntry>) {
247        if self.vec_unready.is_empty() {
248            return;
249        }
250
251        let mut index_map: HashMap<&str, usize> = HashMap::with_capacity(names.len());
252        // Using rev because earlier ones take precedence when names overlap
253        for (i, nm) in names.iter().rev().enumerate() {
254            index_map.insert(*nm, names.len() - 1 - i);
255        }
256
257        let mut ordered_indexes = Vec::<Option<usize>>::with_capacity(self.vec_unready.len());
258        ordered_indexes.resize(names.len(), None);
259
260        for vec_index in 0..self.vec_unready.len() {
261            let ssnnptr = &self.vec_unready[vec_index];
262            let ptr = ssnnptr.non_null_ptr.as_ptr();
263            let name = unsafe { (*ptr).name.clone() };
264            if let Some(order_index) = index_map.remove(name.as_ref()) {
265                ordered_indexes[order_index] = Some(vec_index);
266            } else {
267                ordered_indexes.push(Some(vec_index));
268            }
269        }
270
271        let mut ag = AsyncGroup::new();
272        let mut n_done = 0;
273        for vec_index_opt in ordered_indexes.iter() {
274            if let Some(vec_index) = vec_index_opt {
275                let ssnnptr = &self.vec_unready[*vec_index];
276                let ptr = ssnnptr.non_null_ptr.as_ptr();
277                let setup_fn = unsafe { (*ptr).setup_fn };
278                let name = unsafe { &(*ptr).name };
279                ag._index = *vec_index;
280                ag._name = name.clone();
281                if let Err(err) = setup_fn(ptr, &mut ag) {
282                    errors.push(ErrEntry {
283                        index: *vec_index,
284                        name: name.clone(),
285                        err,
286                    });
287                    break;
288                }
289            }
290            n_done += 1;
291        }
292        ag.join_and_collect_errors(errors);
293
294        if errors.is_empty() {
295            let old_unready = mem::take(&mut self.vec_unready);
296            // Maximizing performance by pre-allocating the required capacity.
297            self.vec_ready
298                .reserve(ordered_indexes.iter().flatten().count());
299            for vec_index in ordered_indexes.iter().flatten() {
300                self.vec_ready.push(old_unready[*vec_index]);
301            }
302        } else {
303            for vec_index in ordered_indexes.iter().take(n_done).flatten().rev() {
304                let ssnnptr = &self.vec_unready[*vec_index];
305                let ptr = ssnnptr.non_null_ptr.as_ptr();
306                let close_fn = unsafe { (*ptr).close_fn };
307                close_fn(ptr);
308            }
309        }
310    }
311
312    pub(crate) fn copy_ds_ready_to_map(&self, index_map: &mut HashMap<Arc<str>, (bool, usize)>) {
313        for (i, ssnnptr) in self.vec_ready.iter().enumerate() {
314            let ptr = ssnnptr.non_null_ptr.as_ptr();
315            let name = unsafe { (*ptr).name.clone() };
316            index_map.insert(name, (self.local, i));
317        }
318    }
319
320    pub(crate) fn create_data_conn<C>(
321        &self,
322        index: usize,
323        name: impl AsRef<str>,
324    ) -> errs::Result<Box<DataConnContainer>>
325    where
326        C: DataConn + 'static,
327    {
328        if let Some(ssnnptr) = self.vec_ready.get(index) {
329            let ptr = ssnnptr.non_null_ptr.as_ptr();
330            let type_id = any::TypeId::of::<C>();
331            let is_fn = unsafe { (*ptr).is_data_conn_fn };
332            let create_data_conn_fn = unsafe { (*ptr).create_data_conn_fn };
333            if !is_fn(type_id) {
334                Err(errs::Err::new(DataSrcError::FailToCastDataConn {
335                    name: name.as_ref().into(),
336                    target_type: any::type_name::<C>(),
337                }))
338            } else {
339                match create_data_conn_fn(ptr) {
340                    Ok(boxed) => Ok(boxed),
341                    Err(err) => Err(errs::Err::with_source(
342                        DataSrcError::FailToCreateDataConn {
343                            name: name.as_ref().into(),
344                            data_conn_type: any::type_name::<C>(),
345                        },
346                        err,
347                    )),
348                }
349            }
350        } else {
351            Err(errs::Err::new(
352                DataSrcError::NotFoundDataSrcToCreateDataConn {
353                    name: name.as_ref().into(),
354                    data_conn_type: any::type_name::<C>(),
355                },
356            ))
357        }
358    }
359}
360
361impl Drop for DataSrcManager {
362    fn drop(&mut self) {
363        self.close();
364    }
365}
366
367#[cfg_attr(coverage_nightly, coverage(off))]
368#[cfg(test)]
369mod tests_of_data_src {
370    use super::*;
371    use std::sync::{Arc, Mutex};
372
373    struct SyncDataConn {}
374    impl SyncDataConn {
375        fn new() -> Self {
376            Self {}
377        }
378    }
379    impl DataConn for SyncDataConn {
380        fn commit(&mut self, _ag: &mut AsyncGroup) -> errs::Result<()> {
381            Ok(())
382        }
383        fn is_committed(&self) -> bool {
384            false
385        }
386        fn rollback(&mut self, _ag: &mut AsyncGroup) -> errs::Result<()> {
387            Ok(())
388        }
389        fn close(&mut self) {}
390    }
391
392    struct AsyncDataConn {}
393    impl AsyncDataConn {
394        fn new() -> Self {
395            Self {}
396        }
397    }
398    impl DataConn for AsyncDataConn {
399        fn commit(&mut self, _ag: &mut AsyncGroup) -> errs::Result<()> {
400            Ok(())
401        }
402        fn is_committed(&self) -> bool {
403            false
404        }
405        fn rollback(&mut self, _ag: &mut AsyncGroup) -> errs::Result<()> {
406            Ok(())
407        }
408        fn close(&mut self) {}
409    }
410
411    struct SyncDataSrc {
412        id: i8,
413        logger: Arc<Mutex<Vec<String>>>,
414        fail_to_setup: bool,
415        fail_to_create_data_conn: bool,
416    }
417    impl SyncDataSrc {
418        fn new(id: i8, logger: Arc<Mutex<Vec<String>>>, fail_to_setup: bool) -> Self {
419            logger
420                .lock()
421                .unwrap()
422                .push(format!("SyncDataSrc::new {}", id));
423            Self {
424                id,
425                logger: logger,
426                fail_to_setup,
427                fail_to_create_data_conn: false,
428            }
429        }
430        fn new_for_fail_to_create_data_conn(id: i8, logger: Arc<Mutex<Vec<String>>>) -> Self {
431            Self {
432                id,
433                logger: logger,
434                fail_to_setup: false,
435                fail_to_create_data_conn: true,
436            }
437        }
438    }
439    impl Drop for SyncDataSrc {
440        fn drop(&mut self) {
441            self.logger
442                .lock()
443                .unwrap()
444                .push(format!("SyncDataSrc::drop {}", self.id));
445        }
446    }
447    impl DataSrc<SyncDataConn> for SyncDataSrc {
448        fn setup(&mut self, _ag: &mut AsyncGroup) -> errs::Result<()> {
449            if self.fail_to_setup {
450                self.logger
451                    .lock()
452                    .unwrap()
453                    .push(format!("SyncDataSrc::setup {} failed", self.id));
454                return Err(errs::Err::new("XXX".to_string()));
455            }
456            self.logger
457                .lock()
458                .unwrap()
459                .push(format!("SyncDataSrc::setup {}", self.id));
460            Ok(())
461        }
462        fn close(&mut self) {
463            self.logger
464                .lock()
465                .unwrap()
466                .push(format!("SyncDataSrc::close {}", self.id));
467        }
468        fn create_data_conn(&mut self) -> errs::Result<Box<SyncDataConn>> {
469            {
470                self.logger
471                    .lock()
472                    .unwrap()
473                    .push(format!("SyncDataSrc::create_data_conn {}", self.id));
474            }
475            if self.fail_to_create_data_conn {
476                return Err(errs::Err::new("eeee".to_string()));
477            }
478            let conn = SyncDataConn::new();
479            Ok(Box::new(conn))
480        }
481    }
482
483    struct AsyncDataSrc {
484        id: i8,
485        fail: bool,
486        logger: Arc<Mutex<Vec<String>>>,
487        wait: u64,
488    }
489    impl AsyncDataSrc {
490        fn new(id: i8, logger: Arc<Mutex<Vec<String>>>, fail: bool, wait: u64) -> Self {
491            logger
492                .lock()
493                .unwrap()
494                .push(format!("AsyncDataSrc::new {}", id));
495            Self {
496                id,
497                fail,
498                logger,
499                wait,
500            }
501        }
502    }
503    impl Drop for AsyncDataSrc {
504        fn drop(&mut self) {
505            self.logger
506                .lock()
507                .unwrap()
508                .push(format!("AsyncDataSrc::drop {}", self.id));
509        }
510    }
511    impl DataSrc<AsyncDataConn> for AsyncDataSrc {
512        fn setup(&mut self, ag: &mut AsyncGroup) -> errs::Result<()> {
513            let logger = self.logger.clone();
514            let fail = self.fail;
515            let id = self.id;
516            let wait = self.wait;
517            ag.add(move || {
518                std::thread::sleep(std::time::Duration::from_millis(wait));
519                let mut logger = logger.lock().unwrap();
520                if fail {
521                    logger.push(format!("AsyncDataSrc::setup {} failed to setup", id));
522                    return Err(errs::Err::new("XXX".to_string()));
523                }
524                logger.push(format!("AsyncDataSrc::setup {}", id));
525                Ok(())
526            });
527            Ok(())
528        }
529        fn close(&mut self) {
530            self.logger
531                .lock()
532                .unwrap()
533                .push(format!("AsyncDataSrc::close {}", self.id));
534        }
535        fn create_data_conn(&mut self) -> errs::Result<Box<AsyncDataConn>> {
536            {
537                self.logger
538                    .lock()
539                    .unwrap()
540                    .push(format!("AsyncDataSrc::create_data_conn {}", self.id));
541            }
542            let conn = AsyncDataConn::new();
543            Ok(Box::new(conn))
544        }
545    }
546
547    #[test]
548    fn test_of_new() {
549        let manager = DataSrcManager::new(true);
550        assert!(manager.local);
551        assert_eq!(manager.vec_unready.len(), 0);
552        assert_eq!(manager.vec_ready.len(), 0);
553
554        let manager = DataSrcManager::new(false);
555        assert!(!manager.local);
556        assert_eq!(manager.vec_unready.len(), 0);
557        assert_eq!(manager.vec_ready.len(), 0);
558    }
559
560    #[test]
561    fn test_of_prepend() {
562        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
563
564        {
565            let mut vec = Vec::<SendSyncNonNull<DataSrcContainer>>::new();
566
567            let ds = SyncDataSrc::new(1, logger.clone(), false);
568            let boxed = Box::new(DataSrcContainer::new("foo", ds, true));
569            let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
570            vec.push(SendSyncNonNull::new(ptr));
571
572            let ds = AsyncDataSrc::new(2, logger.clone(), false, 0);
573            let boxed = Box::new(DataSrcContainer::new("bar", ds, true));
574            let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
575            vec.push(SendSyncNonNull::new(ptr));
576
577            let mut manager = DataSrcManager::new(true);
578            manager.prepend(vec);
579
580            assert!(manager.local);
581            assert_eq!(manager.vec_unready.len(), 2);
582            assert_eq!(manager.vec_ready.len(), 0);
583
584            assert_eq!(
585                unsafe { manager.vec_unready[0].non_null_ptr.as_ref().name.clone() },
586                "foo".into()
587            );
588            assert_eq!(
589                unsafe { manager.vec_unready[1].non_null_ptr.as_ref().name.clone() },
590                "bar".into()
591            );
592
593            let mut vec = Vec::<SendSyncNonNull<DataSrcContainer>>::new();
594
595            let ds = SyncDataSrc::new(3, logger.clone(), false);
596            let boxed = Box::new(DataSrcContainer::new("baz", ds, true));
597            let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
598            vec.push(SendSyncNonNull::new(ptr));
599
600            let ds = AsyncDataSrc::new(4, logger.clone(), false, 0);
601            let boxed = Box::new(DataSrcContainer::new("qux", ds, true));
602            let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
603            vec.push(SendSyncNonNull::new(ptr));
604
605            manager.prepend(vec);
606
607            assert!(manager.local);
608            assert_eq!(manager.vec_unready.len(), 4);
609            assert_eq!(manager.vec_ready.len(), 0);
610
611            assert_eq!(
612                unsafe { manager.vec_unready[0].non_null_ptr.as_ref().name.clone() },
613                "baz".into()
614            );
615            assert_eq!(
616                unsafe { manager.vec_unready[1].non_null_ptr.as_ref().name.clone() },
617                "qux".into()
618            );
619            assert_eq!(
620                unsafe { manager.vec_unready[2].non_null_ptr.as_ref().name.clone() },
621                "foo".into()
622            );
623            assert_eq!(
624                unsafe { manager.vec_unready[3].non_null_ptr.as_ref().name.clone() },
625                "bar".into()
626            );
627        }
628
629        assert_eq!(
630            *logger.lock().unwrap(),
631            vec![
632                "SyncDataSrc::new 1",
633                "AsyncDataSrc::new 2",
634                "SyncDataSrc::new 3",
635                "AsyncDataSrc::new 4",
636                "AsyncDataSrc::drop 2",
637                "SyncDataSrc::drop 1",
638                "AsyncDataSrc::drop 4",
639                "SyncDataSrc::drop 3",
640            ],
641        );
642    }
643
644    #[test]
645    fn test_of_add() {
646        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
647
648        {
649            let mut manager = DataSrcManager::new(true);
650
651            let ds = SyncDataSrc::new(1, logger.clone(), false);
652            manager.add("foo", ds);
653
654            assert!(manager.local);
655            assert_eq!(manager.vec_unready.len(), 1);
656            assert_eq!(manager.vec_ready.len(), 0);
657
658            assert_eq!(
659                unsafe { manager.vec_unready[0].non_null_ptr.as_ref().name.clone() },
660                "foo".into()
661            );
662
663            let ds = AsyncDataSrc::new(2, logger.clone(), false, 0);
664            manager.add("bar", ds);
665
666            assert!(manager.local);
667            assert_eq!(manager.vec_unready.len(), 2);
668            assert_eq!(manager.vec_ready.len(), 0);
669
670            assert_eq!(
671                unsafe { manager.vec_unready[0].non_null_ptr.as_ref().name.clone() },
672                "foo".into()
673            );
674            assert_eq!(
675                unsafe { manager.vec_unready[1].non_null_ptr.as_ref().name.clone() },
676                "bar".into()
677            );
678        }
679
680        assert_eq!(
681            *logger.lock().unwrap(),
682            vec![
683                "SyncDataSrc::new 1",
684                "AsyncDataSrc::new 2",
685                "AsyncDataSrc::drop 2",
686                "SyncDataSrc::drop 1",
687            ],
688        );
689    }
690
691    #[test]
692    fn test_of_remove() {
693        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
694
695        {
696            let mut manager = DataSrcManager::new(true);
697
698            let ds1 = SyncDataSrc::new(1, logger.clone(), false);
699            let boxed = Box::new(DataSrcContainer::new("foo", ds1, true));
700            let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
701            manager.vec_unready.push(SendSyncNonNull::new(ptr));
702
703            let ds2 = AsyncDataSrc::new(2, logger.clone(), false, 0);
704            let boxed = Box::new(DataSrcContainer::new("bar", ds2, true));
705            let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
706            manager.vec_unready.push(SendSyncNonNull::new(ptr));
707
708            let ds3 = SyncDataSrc::new(3, logger.clone(), false);
709            let boxed = Box::new(DataSrcContainer::new("baz", ds3, true));
710            let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
711            manager.vec_ready.push(SendSyncNonNull::new(ptr));
712
713            let ds4 = AsyncDataSrc::new(4, logger.clone(), false, 0);
714            let boxed = Box::new(DataSrcContainer::new("qux", ds4, true));
715            let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
716            manager.vec_ready.push(SendSyncNonNull::new(ptr));
717
718            assert!(manager.local);
719            assert_eq!(manager.vec_unready.len(), 2);
720            assert_eq!(manager.vec_ready.len(), 2);
721
722            manager.remove("baz");
723            manager.remove("foo");
724            manager.remove("qux");
725            manager.remove("bar");
726        }
727
728        assert_eq!(
729            *logger.lock().unwrap(),
730            vec![
731                "SyncDataSrc::new 1",
732                "AsyncDataSrc::new 2",
733                "SyncDataSrc::new 3",
734                "AsyncDataSrc::new 4",
735                "SyncDataSrc::close 3",
736                "SyncDataSrc::drop 3",
737                "SyncDataSrc::drop 1",
738                "AsyncDataSrc::close 4",
739                "AsyncDataSrc::drop 4",
740                "AsyncDataSrc::drop 2",
741            ],
742        );
743    }
744
745    #[test]
746    fn test_of_close() {
747        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
748
749        {
750            let mut manager = DataSrcManager::new(true);
751
752            let ds1 = SyncDataSrc::new(1, logger.clone(), false);
753            let boxed = Box::new(DataSrcContainer::new("foo", ds1, true));
754            let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
755            manager.vec_unready.push(SendSyncNonNull::new(ptr));
756
757            let ds2 = AsyncDataSrc::new(2, logger.clone(), false, 0);
758            let boxed = Box::new(DataSrcContainer::new("bar", ds2, true));
759            let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
760            manager.vec_unready.push(SendSyncNonNull::new(ptr));
761
762            let ds3 = SyncDataSrc::new(3, logger.clone(), false);
763            let boxed = Box::new(DataSrcContainer::new("baz", ds3, true));
764            let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
765            manager.vec_ready.push(SendSyncNonNull::new(ptr));
766
767            let ds4 = AsyncDataSrc::new(4, logger.clone(), false, 0);
768            let boxed = Box::new(DataSrcContainer::new("qux", ds4, true));
769            let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<DataSrcContainer>();
770            manager.vec_ready.push(SendSyncNonNull::new(ptr));
771
772            assert!(manager.local);
773            assert_eq!(manager.vec_unready.len(), 2);
774            assert_eq!(manager.vec_ready.len(), 2);
775
776            manager.close();
777        }
778
779        assert_eq!(
780            *logger.lock().unwrap(),
781            vec![
782                "SyncDataSrc::new 1",
783                "AsyncDataSrc::new 2",
784                "SyncDataSrc::new 3",
785                "AsyncDataSrc::new 4",
786                "AsyncDataSrc::close 4",
787                "AsyncDataSrc::drop 4",
788                "SyncDataSrc::close 3",
789                "SyncDataSrc::drop 3",
790                "AsyncDataSrc::drop 2",
791                "SyncDataSrc::drop 1",
792            ],
793        );
794    }
795
796    #[test]
797    fn setup_no_data_src() {
798        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
799
800        {
801            let mut manager = DataSrcManager::new(true);
802
803            assert!(manager.local);
804            assert_eq!(manager.vec_unready.len(), 0);
805            assert_eq!(manager.vec_ready.len(), 0);
806
807            let mut errors = Vec::new();
808            manager.setup(&mut errors);
809
810            assert_eq!(errors.len(), 0);
811
812            assert!(manager.local);
813            assert_eq!(manager.vec_unready.len(), 0);
814            assert_eq!(manager.vec_ready.len(), 0);
815        }
816
817        assert_eq!(logger.lock().unwrap().len(), 0);
818    }
819
820    #[test]
821    fn test_of_setup_and_ok() {
822        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
823
824        {
825            let mut manager = DataSrcManager::new(true);
826
827            let ds1 = SyncDataSrc::new(1, logger.clone(), false);
828            manager.add("foo", ds1);
829
830            let ds2 = SyncDataSrc::new(2, logger.clone(), false);
831            manager.add("bar", ds2);
832
833            assert!(manager.local);
834            assert_eq!(manager.vec_unready.len(), 2);
835            assert_eq!(manager.vec_ready.len(), 0);
836
837            let mut vec = Vec::new();
838            manager.setup(&mut vec);
839
840            assert!(manager.local);
841            assert_eq!(manager.vec_unready.len(), 0);
842            assert_eq!(manager.vec_ready.len(), 2);
843        }
844
845        assert_eq!(
846            *logger.lock().unwrap(),
847            vec![
848                "SyncDataSrc::new 1",
849                "SyncDataSrc::new 2",
850                "SyncDataSrc::setup 1",
851                "SyncDataSrc::setup 2",
852                "SyncDataSrc::close 2",
853                "SyncDataSrc::drop 2",
854                "SyncDataSrc::close 1",
855                "SyncDataSrc::drop 1",
856            ],
857        );
858    }
859
860    #[test]
861    fn test_of_setup_but_error() {
862        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
863
864        {
865            let mut manager = DataSrcManager::new(true);
866
867            let ds1 = SyncDataSrc::new(1, logger.clone(), false);
868            manager.add("foo", ds1);
869
870            let ds2 = SyncDataSrc::new(2, logger.clone(), true);
871            manager.add("bar", ds2);
872
873            let ds3 = SyncDataSrc::new(3, logger.clone(), true);
874            manager.add("bar", ds3);
875
876            assert!(manager.local);
877            assert_eq!(manager.vec_unready.len(), 3);
878            assert_eq!(manager.vec_ready.len(), 0);
879
880            let mut errors = Vec::new();
881            manager.setup(&mut errors);
882
883            assert!(manager.local);
884            assert_eq!(manager.vec_unready.len(), 3);
885            assert_eq!(manager.vec_ready.len(), 0);
886
887            assert_eq!(errors.len(), 1);
888            assert_eq!(errors[0].index, 1);
889            assert_eq!(errors[0].name, "bar".into());
890            #[cfg(unix)]
891            assert_eq!(format!("{:?}", errors[0].err), "errs::Err { reason = alloc::string::String \"XXX\", file = src/data_src/mod.rs, line = 454 }");
892            #[cfg(windows)]
893            assert_eq!(format!("{:?}", errors[0].err), "errs::Err { reason = alloc::string::String \"XXX\", file = src\\data_src\\mod.rs, line = 454 }");
894        }
895
896        assert_eq!(
897            *logger.lock().unwrap(),
898            vec![
899                "SyncDataSrc::new 1",
900                "SyncDataSrc::new 2",
901                "SyncDataSrc::new 3",
902                "SyncDataSrc::setup 1",
903                "SyncDataSrc::setup 2 failed",
904                "SyncDataSrc::close 1",
905                "SyncDataSrc::drop 3",
906                "SyncDataSrc::drop 2",
907                "SyncDataSrc::drop 1",
908            ],
909        );
910    }
911
912    #[test]
913    fn setup_with_order_no_data_src() {
914        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
915
916        {
917            let mut manager = DataSrcManager::new(true);
918
919            assert!(manager.local);
920            assert_eq!(manager.vec_unready.len(), 0);
921            assert_eq!(manager.vec_ready.len(), 0);
922
923            let mut errors = Vec::new();
924            manager.setup_with_order(&["foo", "bar"], &mut errors);
925
926            assert_eq!(errors.len(), 0);
927
928            assert!(manager.local);
929            assert_eq!(manager.vec_unready.len(), 0);
930            assert_eq!(manager.vec_ready.len(), 0);
931        }
932
933        assert_eq!(logger.lock().unwrap().len(), 0);
934    }
935
936    #[test]
937    fn test_of_setup_with_order_and_ok() {
938        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
939
940        {
941            let mut manager = DataSrcManager::new(true);
942
943            let ds1 = SyncDataSrc::new(1, logger.clone(), false);
944            manager.add("foo", ds1);
945
946            let ds2 = SyncDataSrc::new(2, logger.clone(), false);
947            manager.add("bar", ds2);
948
949            let ds3 = SyncDataSrc::new(3, logger.clone(), false);
950            manager.add("baz", ds3);
951
952            assert!(manager.local);
953            assert_eq!(manager.vec_unready.len(), 3);
954            assert_eq!(manager.vec_ready.len(), 0);
955
956            let mut errors = Vec::new();
957            manager.setup_with_order(&["baz", "foo"], &mut errors);
958
959            assert!(manager.local);
960            assert_eq!(manager.vec_unready.len(), 0);
961            assert_eq!(manager.vec_ready.len(), 3);
962
963            assert_eq!(errors.len(), 0);
964        }
965
966        assert_eq!(
967            *logger.lock().unwrap(),
968            vec![
969                "SyncDataSrc::new 1",
970                "SyncDataSrc::new 2",
971                "SyncDataSrc::new 3",
972                "SyncDataSrc::setup 3",
973                "SyncDataSrc::setup 1",
974                "SyncDataSrc::setup 2",
975                "SyncDataSrc::close 2",
976                "SyncDataSrc::drop 2",
977                "SyncDataSrc::close 1",
978                "SyncDataSrc::drop 1",
979                "SyncDataSrc::close 3",
980                "SyncDataSrc::drop 3",
981            ],
982        );
983    }
984
985    #[test]
986    fn test_of_setup_with_order_but_fail() {
987        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
988
989        {
990            let mut manager = DataSrcManager::new(true);
991
992            let ds1 = SyncDataSrc::new(1, logger.clone(), true);
993            manager.add("foo", ds1);
994
995            let ds2 = SyncDataSrc::new(2, logger.clone(), true);
996            manager.add("bar", ds2);
997
998            let ds3 = SyncDataSrc::new(3, logger.clone(), false);
999            manager.add("baz", ds3);
1000
1001            let ds4 = SyncDataSrc::new(4, logger.clone(), false);
1002            manager.add("qux", ds4);
1003
1004            assert!(manager.local);
1005            assert_eq!(manager.vec_unready.len(), 4);
1006            assert_eq!(manager.vec_ready.len(), 0);
1007
1008            let mut errors = Vec::new();
1009            manager.setup_with_order(&["qux", "baz", "foo"], &mut errors);
1010
1011            assert!(manager.local);
1012            assert_eq!(manager.vec_unready.len(), 4);
1013            assert_eq!(manager.vec_ready.len(), 0);
1014
1015            assert_eq!(errors.len(), 1);
1016            assert_eq!(errors[0].index, 0);
1017            assert_eq!(errors[0].name, "foo".into());
1018            #[cfg(unix)]
1019            assert_eq!(format!("{:?}", errors[0].err), "errs::Err { reason = alloc::string::String \"XXX\", file = src/data_src/mod.rs, line = 454 }");
1020            #[cfg(windows)]
1021            assert_eq!(format!("{:?}", errors[0].err), "errs::Err { reason = alloc::string::String \"XXX\", file = src\\data_src\\mod.rs, line = 454 }");
1022        }
1023
1024        assert_eq!(
1025            *logger.lock().unwrap(),
1026            vec![
1027                "SyncDataSrc::new 1",
1028                "SyncDataSrc::new 2",
1029                "SyncDataSrc::new 3",
1030                "SyncDataSrc::new 4",
1031                "SyncDataSrc::setup 4",
1032                "SyncDataSrc::setup 3",
1033                "SyncDataSrc::setup 1 failed",
1034                "SyncDataSrc::close 3",
1035                "SyncDataSrc::close 4",
1036                "SyncDataSrc::drop 4",
1037                "SyncDataSrc::drop 3",
1038                "SyncDataSrc::drop 2",
1039                "SyncDataSrc::drop 1",
1040            ],
1041        );
1042    }
1043
1044    #[test]
1045    fn test_of_setup_with_order_containing_duplicated_name_and_ok() {
1046        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
1047
1048        {
1049            let mut manager = DataSrcManager::new(true);
1050
1051            let ds1 = SyncDataSrc::new(1, logger.clone(), false);
1052            manager.add("foo", ds1);
1053
1054            let ds2 = SyncDataSrc::new(2, logger.clone(), false);
1055            manager.add("bar", ds2);
1056
1057            let ds3 = SyncDataSrc::new(3, logger.clone(), false);
1058            manager.add("baz", ds3);
1059
1060            assert!(manager.local);
1061            assert_eq!(manager.vec_unready.len(), 3);
1062            assert_eq!(manager.vec_ready.len(), 0);
1063
1064            let mut vec = Vec::new();
1065            manager.setup_with_order(&["baz", "baz", "foo"], &mut vec);
1066
1067            assert!(manager.local);
1068            assert_eq!(manager.vec_unready.len(), 0);
1069            assert_eq!(manager.vec_ready.len(), 3);
1070        }
1071
1072        assert_eq!(
1073            *logger.lock().unwrap(),
1074            vec![
1075                "SyncDataSrc::new 1",
1076                "SyncDataSrc::new 2",
1077                "SyncDataSrc::new 3",
1078                "SyncDataSrc::setup 3",
1079                "SyncDataSrc::setup 1",
1080                "SyncDataSrc::setup 2",
1081                "SyncDataSrc::close 2",
1082                "SyncDataSrc::drop 2",
1083                "SyncDataSrc::close 1",
1084                "SyncDataSrc::drop 1",
1085                "SyncDataSrc::close 3",
1086                "SyncDataSrc::drop 3",
1087            ],
1088        );
1089    }
1090
1091    #[test]
1092    fn test_of_setup_with_order_containing_duplicated_name_and_ok_2() {
1093        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
1094
1095        {
1096            let mut manager = DataSrcManager::new(true);
1097
1098            let ds1 = SyncDataSrc::new(1, logger.clone(), false);
1099            manager.add("foo", ds1);
1100
1101            let ds2 = SyncDataSrc::new(2, logger.clone(), false);
1102            manager.add("bar", ds2);
1103
1104            let ds3 = SyncDataSrc::new(3, logger.clone(), false);
1105            manager.add("baz", ds3);
1106
1107            let ds4 = SyncDataSrc::new(4, logger.clone(), false);
1108            manager.add("qux", ds4);
1109
1110            assert!(manager.local);
1111            assert_eq!(manager.vec_unready.len(), 4);
1112            assert_eq!(manager.vec_ready.len(), 0);
1113
1114            let mut vec = Vec::new();
1115            manager.setup_with_order(&["baz", "foo", "baz", "qux"], &mut vec);
1116
1117            assert!(manager.local);
1118            assert_eq!(manager.vec_unready.len(), 0);
1119            assert_eq!(manager.vec_ready.len(), 4);
1120        }
1121
1122        assert_eq!(
1123            *logger.lock().unwrap(),
1124            vec![
1125                "SyncDataSrc::new 1",
1126                "SyncDataSrc::new 2",
1127                "SyncDataSrc::new 3",
1128                "SyncDataSrc::new 4",
1129                "SyncDataSrc::setup 3",
1130                "SyncDataSrc::setup 1",
1131                "SyncDataSrc::setup 4",
1132                "SyncDataSrc::setup 2",
1133                "SyncDataSrc::close 2",
1134                "SyncDataSrc::drop 2",
1135                "SyncDataSrc::close 4",
1136                "SyncDataSrc::drop 4",
1137                "SyncDataSrc::close 1",
1138                "SyncDataSrc::drop 1",
1139                "SyncDataSrc::close 3",
1140                "SyncDataSrc::drop 3",
1141            ],
1142        );
1143    }
1144
1145    #[test]
1146    fn test_of_setup_with_order_buf_one_of_names_is_not_used() {
1147        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
1148
1149        {
1150            let mut manager = DataSrcManager::new(true);
1151
1152            let ds1 = SyncDataSrc::new(1, logger.clone(), false);
1153            manager.add("foo", ds1);
1154
1155            let ds2 = SyncDataSrc::new(2, logger.clone(), false);
1156            manager.add("bar", ds2);
1157
1158            let ds3 = SyncDataSrc::new(3, logger.clone(), false);
1159            manager.add("baz", ds3);
1160
1161            assert!(manager.local);
1162            assert_eq!(manager.vec_unready.len(), 3);
1163            assert_eq!(manager.vec_ready.len(), 0);
1164
1165            let mut vec = Vec::new();
1166            manager.setup_with_order(&["baz", "foo", "xxx"], &mut vec);
1167
1168            assert!(manager.local);
1169            assert_eq!(manager.vec_unready.len(), 0);
1170            assert_eq!(manager.vec_ready.len(), 3);
1171        }
1172
1173        assert_eq!(
1174            *logger.lock().unwrap(),
1175            vec![
1176                "SyncDataSrc::new 1",
1177                "SyncDataSrc::new 2",
1178                "SyncDataSrc::new 3",
1179                "SyncDataSrc::setup 3",
1180                "SyncDataSrc::setup 1",
1181                "SyncDataSrc::setup 2",
1182                "SyncDataSrc::close 2",
1183                "SyncDataSrc::drop 2",
1184                "SyncDataSrc::close 1",
1185                "SyncDataSrc::drop 1",
1186                "SyncDataSrc::close 3",
1187                "SyncDataSrc::drop 3",
1188            ],
1189        );
1190    }
1191
1192    #[test]
1193    fn test_of_setup_with_order_buf_one_of_names_is_not_used_2() {
1194        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
1195
1196        {
1197            let mut manager = DataSrcManager::new(true);
1198
1199            let ds1 = SyncDataSrc::new(1, logger.clone(), false);
1200            manager.add("foo", ds1);
1201
1202            let ds2 = SyncDataSrc::new(2, logger.clone(), false);
1203            manager.add("bar", ds2);
1204
1205            assert!(manager.local);
1206            assert_eq!(manager.vec_unready.len(), 2);
1207            assert_eq!(manager.vec_ready.len(), 0);
1208
1209            let mut errors = Vec::new();
1210            manager.setup_with_order(&["baz", "foo", "xxx"], &mut errors);
1211
1212            assert!(manager.local);
1213            assert_eq!(manager.vec_unready.len(), 0);
1214            assert_eq!(manager.vec_ready.len(), 2);
1215
1216            assert!(errors.is_empty());
1217        }
1218    }
1219
1220    #[test]
1221    fn test_of_copy_ds_ready_to_map() {
1222        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
1223        let mut errors = Vec::new();
1224
1225        let mut index_map = HashMap::<Arc<str>, (bool, usize)>::new();
1226
1227        let manager = DataSrcManager::new(true);
1228        manager.copy_ds_ready_to_map(&mut index_map);
1229        assert!(index_map.is_empty());
1230
1231        let mut manager = DataSrcManager::new(true);
1232        let ds1 = SyncDataSrc::new(1, logger.clone(), false);
1233        manager.add("foo", ds1);
1234        manager.setup(&mut errors);
1235        assert!(errors.is_empty());
1236        manager.copy_ds_ready_to_map(&mut index_map);
1237        assert_eq!(index_map.len(), 1);
1238        assert_eq!(index_map.get("foo").unwrap(), &(true, 0));
1239
1240        let mut manager = DataSrcManager::new(false);
1241        let ds2 = AsyncDataSrc::new(2, logger.clone(), false, 0);
1242        let ds3 = SyncDataSrc::new(3, logger.clone(), false);
1243        manager.add("bar", ds2);
1244        manager.add("baz", ds3);
1245        manager.setup(&mut errors);
1246        assert!(errors.is_empty());
1247        manager.copy_ds_ready_to_map(&mut index_map);
1248        assert_eq!(index_map.len(), 3);
1249        assert_eq!(index_map.get("foo").unwrap(), &(true, 0));
1250        assert_eq!(index_map.get("bar").unwrap(), &(false, 0));
1251        assert_eq!(index_map.get("baz").unwrap(), &(false, 1));
1252    }
1253
1254    #[test]
1255    fn add_copydsreadytomap_remove_copydsreadytomap() {
1256        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
1257        let mut errors = Vec::new();
1258
1259        let mut manager = DataSrcManager::new(true);
1260
1261        let ds1 = SyncDataSrc::new(1, logger.clone(), false);
1262        manager.add("foo", ds1);
1263
1264        let ds2 = SyncDataSrc::new(2, logger.clone(), false);
1265        manager.add("bar", ds2);
1266
1267        manager.setup(&mut errors);
1268        assert!(errors.is_empty());
1269
1270        let mut index_map = HashMap::<Arc<str>, (bool, usize)>::new();
1271        manager.copy_ds_ready_to_map(&mut index_map);
1272        assert_eq!(index_map.len(), 2);
1273        assert_eq!(index_map.get("foo").unwrap(), &(true, 0));
1274        assert_eq!(index_map.get("bar").unwrap(), &(true, 1));
1275
1276        manager.remove("foo");
1277
1278        manager.setup(&mut errors);
1279        assert!(errors.is_empty());
1280
1281        let mut index_map = HashMap::<Arc<str>, (bool, usize)>::new();
1282        manager.copy_ds_ready_to_map(&mut index_map);
1283        assert_eq!(index_map.len(), 1);
1284        assert_eq!(index_map.get("bar").unwrap(), &(true, 0));
1285    }
1286
1287    #[test]
1288    fn test_of_create_data_conn_and_ok() {
1289        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
1290        let mut errors = Vec::new();
1291
1292        let mut manager = DataSrcManager::new(true);
1293        let ds1 = SyncDataSrc::new(1, logger.clone(), false);
1294        manager.add("foo", ds1);
1295        manager.setup(&mut errors);
1296
1297        if let Ok(boxed) = manager.create_data_conn::<SyncDataConn>(0, "foo") {
1298            assert_eq!(boxed.name.clone(), "foo".into());
1299        } else {
1300            panic!();
1301        }
1302    }
1303
1304    #[test]
1305    fn test_of_create_data_conn_but_not_found() {
1306        let mut errors = Vec::new();
1307
1308        let mut manager = DataSrcManager::new(true);
1309        manager.setup(&mut errors);
1310
1311        if let Err(err) = manager.create_data_conn::<SyncDataConn>(0, "foo") {
1312            match err.reason::<DataSrcError>() {
1313                Ok(DataSrcError::NotFoundDataSrcToCreateDataConn {
1314                    name,
1315                    data_conn_type,
1316                }) => {
1317                    assert_eq!(*name, "foo".into());
1318                    assert_eq!(
1319                        *data_conn_type,
1320                        "sabi::data_src::tests_of_data_src::SyncDataConn"
1321                    );
1322                }
1323                _ => panic!(),
1324            }
1325        } else {
1326            panic!();
1327        }
1328    }
1329
1330    #[test]
1331    fn test_of_create_data_conn_but_fail_to_cast() {
1332        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
1333        let mut errors = Vec::new();
1334
1335        let mut manager = DataSrcManager::new(true);
1336        let ds1 = SyncDataSrc::new(1, logger.clone(), false);
1337        manager.add("foo", ds1);
1338        manager.setup(&mut errors);
1339
1340        if let Err(err) = manager.create_data_conn::<AsyncDataConn>(0, "foo") {
1341            match err.reason::<DataSrcError>() {
1342                Ok(DataSrcError::FailToCastDataConn { name, target_type }) => {
1343                    assert_eq!(*name, "foo".into());
1344                    assert_eq!(
1345                        *target_type,
1346                        "sabi::data_src::tests_of_data_src::AsyncDataConn"
1347                    );
1348                }
1349                _ => panic!(),
1350            }
1351        } else {
1352            panic!();
1353        }
1354    }
1355
1356    #[test]
1357    fn test_of_create_data_conn_but_fail_to_create() {
1358        let logger = Arc::new(Mutex::new(Vec::<String>::new()));
1359        let mut errors = Vec::new();
1360
1361        let mut manager = DataSrcManager::new(true);
1362        let ds1 = SyncDataSrc::new_for_fail_to_create_data_conn(1, logger.clone());
1363        manager.add("foo", ds1);
1364        manager.setup(&mut errors);
1365
1366        if let Err(err) = manager.create_data_conn::<SyncDataConn>(0, "foo") {
1367            match err.reason::<DataSrcError>() {
1368                Ok(DataSrcError::FailToCreateDataConn {
1369                    name,
1370                    data_conn_type,
1371                }) => {
1372                    assert_eq!(*name, "foo".into());
1373                    assert_eq!(
1374                        *data_conn_type,
1375                        "sabi::data_src::tests_of_data_src::SyncDataConn"
1376                    );
1377                }
1378                _ => panic!(),
1379            }
1380        } else {
1381            panic!();
1382        }
1383    }
1384}
sabi/data_src/mod.rs

sabi/data_src/
mod.rs
