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
|
//! ref: composer/tests/Composer/Test/Script/EventTest.php
use std::cell::RefCell;
use std::rc::Rc;
use indexmap::IndexMap;
use shirabe::composer::{ComposerHandle, PartialOrFullComposer};
use shirabe::config::Config;
use shirabe::event_dispatcher::Event as BaseEvent;
use shirabe::event_dispatcher::EventInterface;
use shirabe::io::IOInterface;
use shirabe::io::null_io::NullIO;
use shirabe::package::{RootPackageHandle, RootPackageInterfaceHandle};
use shirabe::script::{Event, OriginatingEvent};
fn create_composer_instance() -> ComposerHandle {
let composer =
ComposerHandle::from_rc_unchecked(Rc::new(RefCell::new(PartialOrFullComposer::new_full())));
let config = Rc::new(RefCell::new(Config::new(true, None)));
composer.borrow_mut().set_config(config);
let package: RootPackageInterfaceHandle = RootPackageHandle::new(
"foo".to_string(),
"1.0.0.0".to_string(),
"1.0.0".to_string(),
)
.into();
composer.borrow_mut().set_package(package);
composer
}
#[test]
fn test_event_sets_originating_event() {
let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
let composer = create_composer_instance();
let originating_event = BaseEvent::new("originatingEvent".to_string(), vec![], IndexMap::new());
let mut script_event = Event::new(
"test".to_string(),
composer.downgrade(),
io,
true,
vec![],
IndexMap::new(),
);
assert!(
script_event.get_originating_event().is_none(),
"originatingEvent is initialized as null"
);
script_event.set_originating_event(OriginatingEvent::Base(originating_event));
// assertSame: the originating event passed in is returned unchanged.
assert_eq!(
script_event
.get_originating_event()
.map(EventInterface::get_name),
Some("originatingEvent"),
"getOriginatingEvent() SHOULD return test event"
);
}
#[test]
fn test_event_calculates_nested_originating_event() {
let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
let composer = create_composer_instance();
let originating_event =
BaseEvent::new("upperOriginatingEvent".to_string(), vec![], IndexMap::new());
let mut intermediate_event = Event::new(
"intermediate".to_string(),
composer.downgrade(),
io.clone(),
true,
vec![],
IndexMap::new(),
);
intermediate_event.set_originating_event(OriginatingEvent::Base(originating_event));
let mut script_event = Event::new(
"test".to_string(),
composer.downgrade(),
io,
true,
vec![],
IndexMap::new(),
);
script_event.set_originating_event(OriginatingEvent::Script(Box::new(intermediate_event)));
// assertNotSame/assertSame: compare by name since Rust lacks PHP object identity.
let name = script_event
.get_originating_event()
.map(EventInterface::get_name);
assert_ne!(
name,
Some("intermediate"),
"getOriginatingEvent() SHOULD NOT return intermediate events"
);
assert_eq!(
name,
Some("upperOriginatingEvent"),
"getOriginatingEvent() SHOULD return upper-most event"
);
}
|
