forked from joelhooks/signals-extensions-CommandSignal
/
SignalCommandMapTests.as
166 lines (142 loc) · 5.92 KB
/
SignalCommandMapTests.as
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
package org.robotlegs.base
{
import asunit.asserts.*;
import org.osflash.signals.ISignal;
import org.robotlegs.test.support.*;
import org.robotlegs.adapters.SwiftSuspendersInjector;
import org.robotlegs.base.SignalCommandMap;
import org.robotlegs.core.IInjector;
import org.robotlegs.core.ISignalCommandMap;
public class SignalCommandMapTests
{
private var signalCommandMap:ISignalCommandMap;
private var injector:IInjector;
private var onePropSignal:TestCommandPropertySignal;
private var twoPropSignal:TestTwoPropertySignal;
[Before]
public function setup():void
{
injector = new SwiftSuspendersInjector( );
onePropSignal = new TestCommandPropertySignal();
twoPropSignal = new TestTwoPropertySignal();
signalCommandMap = new SignalCommandMap( injector );
}
[After]
public function teardown():void
{
injector = null;
signalCommandMap = null;
}
[Test]
public function SignalCommandMap_instance_is_ISignalCommandMap():void
{
assertTrue( signalCommandMap is ISignalCommandMap )
}
[Test]
public function mapping_signal_creates_command_mapping():void
{
signalCommandMap.mapSignal( onePropSignal, TestNoPropertiesCommand );
assertTrue( signalCommandMap.hasSignalCommand( onePropSignal, TestNoPropertiesCommand ) )
}
[Test(expects="org.robotlegs.base.ContextError")]
public function mapping_class_with_no_execute_throws_error():void
{
signalCommandMap.mapSignal( onePropSignal, TestNoExecuteCommand );
}
[Test]
public function unmapping_signal_removes_command_mapping():void
{
signalCommandMap.mapSignal( onePropSignal, TestNoPropertiesCommand );
signalCommandMap.unmapSignal( onePropSignal, TestNoPropertiesCommand );
assertFalse( signalCommandMap.hasSignalCommand( onePropSignal, TestNoPropertiesCommand ) );
}
[Test]
public function dispatch_signal_executes_command():void
{
var prop:TestCommandProperty = new TestCommandProperty( );
signalCommandMap.mapSignal( onePropSignal, TestOnePropertyCommand );
onePropSignal.dispatch( prop );
assertTrue( prop.wasExecuted );
}
[Test]
public function multiple_command_properties_values_are_injected():void
{
var propOne:TestCommandProperty = new TestCommandProperty( );
var propTwo:TestCommandProperty2 = new TestCommandProperty2( );
signalCommandMap.mapSignal( twoPropSignal, TestTwoPropertyCommand );
twoPropSignal.dispatch( propOne, propTwo );
assertTrue( propOne.wasExecuted && propTwo.wasExecuted );
}
[Test]
public function command_can_be_executed_multiple_times():void
{
var prop:TestCommandProperty = new TestCommandProperty( );
signalCommandMap.mapSignal( onePropSignal, TestOnePropertyCommand );
onePropSignal.dispatch( prop );
prop.wasExecuted = false;
onePropSignal.dispatch( prop );
assertTrue( prop.wasExecuted );
}
[Test]
public function command_receives_constructor_dependency_from_signal_dispatch():void
{
var prop:TestCommandProperty = new TestCommandProperty( );
signalCommandMap.mapSignal( onePropSignal, TestOnePropertyConstructorCommand );
onePropSignal.dispatch( prop );
assertTrue( prop.wasExecuted );
}
[Test]
public function command_receives_two_constructor_dependencies_from_signal_dispatch():void
{
var propOne:TestCommandProperty = new TestCommandProperty( );
var propTwo:TestCommandProperty2 = new TestCommandProperty2( );
signalCommandMap.mapSignal( twoPropSignal, TestTwoPropertyConstructorCommand );
twoPropSignal.dispatch( propOne, propTwo );
assertTrue( propOne.wasExecuted && propTwo.wasExecuted );
}
[Test]
public function one_shot_command_only_executes_once():void
{
var prop:TestCommandProperty = new TestCommandProperty( );
signalCommandMap.mapSignal( onePropSignal, TestOnePropertyCommand, true );
onePropSignal.dispatch( prop );
assertTrue( prop.wasExecuted );
prop.wasExecuted = false;
onePropSignal.dispatch( prop );
assertFalse( prop.wasExecuted );
}
[Test]
public function mapping_signal_class_returns_instance():void
{
var signal:ISignal = signalCommandMap.mapSignalClass( TestCommandPropertySignal, TestNoPropertiesCommand );
assertTrue(signal is ISignal);
}
[Test]
public function signal_mapped_as_class_maps_signal_instance_with_injector():void
{
var signal:ISignal = signalCommandMap.mapSignalClass( TestCommandPropertySignal, TestNoPropertiesCommand );
var signalTwo:ISignal = injector.instantiate(SignalInjecteeTestClass).signal;
assertSame(signal, signalTwo);
}
[Test]
public function mapping_signal_class_twice_returns_same_signal_instance():void
{
var signalOne:ISignal = signalCommandMap.mapSignalClass( TestCommandPropertySignal, TestNoPropertiesCommand );
var signalTwo:ISignal = signalCommandMap.mapSignalClass( TestCommandPropertySignal, TestOnePropertyCommand );
assertSame(signalOne, signalTwo);
}
[Test]
public function map_signal_class_creates_command_mapping():void
{
var signal:ISignal = signalCommandMap.mapSignalClass( TestCommandPropertySignal, TestNoPropertiesCommand );
assertTrue( signalCommandMap.hasSignalCommand( signal, TestNoPropertiesCommand ) );
}
[Test]
public function unmap_signal_class_removes_command_mapping():void
{
var signal:ISignal = signalCommandMap.mapSignalClass( TestCommandPropertySignal, TestNoPropertiesCommand );
signalCommandMap.unmapSignalClass( TestCommandPropertySignal, TestNoPropertiesCommand );
assertFalse( signalCommandMap.hasSignalCommand( signal, TestNoPropertiesCommand ) );
}
}
}