This repository has been archived by the owner on Sep 20, 2020. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 4
/
LocalAkkaIntegrationTests.groovy
230 lines (194 loc) · 8.03 KB
/
LocalAkkaIntegrationTests.groovy
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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package grails_akka
import static org.junit.Assert.*
import grails_akka_test.actor.GreetingActor
import grails_akka_test.command.ActorCommand
import grails_akka_test.message.GenericMessage
import grails_akka_test.message.Greeting
import grails_akka_test.message.Stop
import grails_akka_test.message.Wait
import org.junit.After
import org.junit.Before
import org.junit.Test
import akka.actor.ActorRef
import akka.actor.ActorSystem
import akka.actor.Props
import akka.testkit.TestProbe
/**
* LocalAkkaIntegrationTests
* <br/>
* Integration tests with a Local Akka System.
*/
class LocalAkkaIntegrationTests
{
// global actor system for this test class, to reuse it in all test methods here
ActorSystem system
ActorRef actor
// the supported mode to mock an actor is with something like this:
TestProbe probe
ActorRef mock
@Before
void setUp()
{
// creates the local actor system
// system = ActorSystem.apply()
system = ActorSystem.create("LocalActorSystem")
println("Created Local Actor System instance: $system")
// get a reference to the greetingActor
// actor = TestActorRef.apply(new Props(GreetingActor), system) // this is the supported way
actor = system.actorOf(new Props(GreetingActor), "greeting_actor") // this is my way (not test-specific) ...
println("Get Actor Reference to GreetingActor: $actor")
// the supported mode to mock an actor is with something like this:
// mock = TestActorRef.apply(new AbstractFunction0() {
// @Override
// Pi.Worker apply() {
// return new Pi.Worker()
// }
// }, system)
// and in any test method then use something like this:
// probe = TestProbe.apply(system)
// mock = probe.ref()
// mock.tell("Hello", probe.ref())
}
@After
void tearDown()
{
// shutdown the local actor system
// if (actor != null) {
// actor.stop()
// }
// if (system != null) {
// println("Shutting down Local Actor System instance: $system")
// system.shutdown()
// }
}
@Test(expected = InstantiationException)
void testClassAvailable_UntypedActor()
{
log.info "testClassAvailable_UntypedActor()"
def className = "akka.actor.UntypedActor" // abstract, so not instantiable ...
def classInstance = Class.forName(className).newInstance()
println("$className instance is: $classInstance")
// assertNotNull classInstance
// here I expect an InstantiationException thrown
}
@Test(expected = InstantiationException)
void testClassAvailable_ActorSystem()
{
log.info "testClassAvailable_ActorSystem()"
def className = "akka.actor.ActorSystem" // abstract, so not instantiable ...
def classInstance = Class.forName(className).newInstance()
println("$className instance is: $classInstance")
// assertNotNull classInstance
// here I expect an InstantiationException thrown
}
@Test
void testLocalAkkaSystem_Greetings()
{
log.info "testLocalAkkaSystem_Greetings()"
// creates the local actor system
// ActorSystem system = ActorSystem.create("GreetingSystem") // commented, to reuse the actor system global in this test class
println("Actor System instance is: $system")
assertNotNull system
// get a reference to our greeting actor
// ActorRef actor = system.actorOf(new Props(GreetingActor), "greeting_actor") // commented, to reuse the actor reference global in this test class
println("Actor Reference instance is: $actor")
assertNotNull actor
// send to the greeting actor a null message
actor.tell(null)
assertNotNull actor // dummy
// send to the greeting actor a Greeting message
actor.tell(new Greeting("Test Greeting"))
assertNotNull actor // dummy
// send to the greeting actor an unknown message
actor.tell(new String("Test String"))
assertNotNull actor // dummy
}
@Test
void testLocalAkkaSystem_OtherCommands()
{
log.info "testLocalAkkaSystem_OtherCommands()"
// creates the local actor system
// ActorSystem system = ActorSystem.create("GreetingSystem") // commented, to reuse the actor system global in this test class
println("Actor System instance is: $system")
assertNotNull system
// get a reference to our greeting actor
// ActorRef actor = system.actorOf(new Props(GreetingActor), "greeting_actor") // commented, to reuse the actor reference global in this test class
println("Actor Reference instance is: $actor")
assertNotNull actor
// send to the greeting actor a sample generic message
actor.tell(new GenericMessage<String>("simple generic message with a String"))
assertNotNull actor // dummy
}
@Test
void testLocalAkkaSystem_Wait()
{
log.info "testLocalAkkaSystem_Wait()"
println("Actor System instance is: $system")
assertNotNull system
println("Actor Reference instance is: $actor")
assertNotNull actor
// send to the greeting actor a Wait message
long sleepTime = 2000 // msec
long startSleep = System.currentTimeMillis()
actor.tell(new Wait(sleepTime))
long stopSleep = System.currentTimeMillis()
long delta = stopSleep - startSleep
// TODO: enable later and make it working ...
// assertTrue delta >= sleepTime
assertNotNull actor // dummy
}
@Test
void testLocalAkkaSystem_Stop()
{
log.info "testLocalAkkaSystem_Stop()"
println("Actor System instance is: $system")
assertNotNull system
println("Actor Reference instance is: $actor")
assertNotNull actor
// send to the greeting actor a stop message
actor.tell(new Stop())
assertNotNull actor // dummy
// // send to the greeting actor a shutdown message
// actor.tell(new Shutdown())
// assertNotNull actor // dummy
// send to the greeting actor an unknown message
actor.tell(new String("Test String"))
assertNotNull actor // dummy
// ok, but note that this actor (after the Shutdown message) will not get this message ...
}
@Test
void testLocalAkkaSystem_ActorCommand()
{
log.info "testLocalAkkaSystem_ActorCommand()"
println("Actor System instance is: $system")
assertNotNull system
println("Actor Reference instance is: $actor")
assertNotNull actor
// wrap sending message to the actor inside a command
ActorCommand cmd = new ActorCommand(actor, new GenericMessage<String>("ActorCommand: simple generic message with a String"))
println("ActorCommand instance is: $cmd")
cmd.execute()
assertNotNull cmd // dummy
// wrap sending message to the actor inside a command
ActorCommand cmd2 = new ActorCommand(actor, new String("ActorCommand: Test String"))
println("ActorCommand instance is: $cmd2")
cmd2.execute()
assertNotNull cmd2 // dummy
}
}