ActionTest.java revision 461a34b466cb4b13dbbc2ec6330b31e217b2ac4e 
1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.messaging.datamodel.action;
18
19import android.os.Bundle;
20import android.os.Parcel;
21import android.os.Parcelable;
22import android.test.suitebuilder.annotation.MediumTest;
23import android.test.suitebuilder.annotation.SmallTest;
24
25import com.android.messaging.BugleTestCase;
26import com.android.messaging.FakeFactory;
27import com.android.messaging.datamodel.DataModelImpl;
28import com.android.messaging.datamodel.action.ActionTestHelpers.StubChatActionMonitor;
29
30import java.util.ArrayList;
31
32@MediumTest
33public class ActionTest extends BugleTestCase {
34    private static final String parameter = "parameter";
35    private static final Object executeActionResult = "executeActionResult";
36    private static final Object processResponseResult = "processResponseResult";
37    private static final Object processFailureResult = "processFailureResult";
38
39    private static final String mActionKey = "TheActionKey";
40    private static final Object mData = "PrivateData";
41    private StubChatActionMonitor mMonitor;
42    private TestChatAction mAction;
43
44    private ArrayList<StubChatActionMonitor.StateTransition> mTransitions;
45
46    @Override
47    public void setUp() throws Exception {
48        super.setUp();
49        FakeFactory.register(getTestContext())
50                .withDataModel(new DataModelImpl(getContext()));
51
52        mMonitor = new StubChatActionMonitor(ActionMonitor.STATE_CREATED, mActionKey,
53                mData);
54        mAction = new TestChatAction(mActionKey, parameter);
55        mTransitions = mMonitor.getTransitions();
56    }
57
58    private void verifyState(final int count, final int from, final int to) {
59        assertEquals(to, mMonitor.getState());
60        assertEquals(mTransitions.size(), count);
61        verifyTransition(count-1, from , to);
62    }
63
64    private void verifyTransition(final int index, final int from, final int to) {
65        assertTrue(mTransitions.size() > index);
66        assertEquals(mAction, mTransitions.get(index).action);
67        assertEquals(from, mTransitions.get(index).from);
68        assertEquals(to, mTransitions.get(index).to);
69    }
70
71    @SmallTest
72    public void testActionStartTransitionsCorrectly() {
73        mMonitor.setState(ActionMonitor.STATE_CREATED);
74
75        ActionMonitor.registerActionMonitor(mAction.actionKey, mMonitor);
76        assertTrue(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
77        assertTrue(ActionMonitor.sActionMonitors.containsValue(mMonitor));
78        assertEquals(ActionMonitor.sActionMonitors.get(mAction.actionKey), mMonitor);
79
80        mAction.markStart();
81        assertEquals("After start state: STATE_QUEUED", ActionMonitor.STATE_QUEUED,
82                mMonitor.getState());
83        verifyState(1, ActionMonitor.STATE_CREATED, ActionMonitor.STATE_QUEUED);
84
85        ActionMonitor.unregisterActionMonitor(mAction.actionKey, mMonitor);
86
87        assertFalse(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
88        assertFalse(ActionMonitor.sActionMonitors.containsValue(mMonitor));
89    }
90
91    @SmallTest
92    public void testActionStartAssertsFromIncorrectState() {
93        mMonitor.setState(ActionMonitor.STATE_UNDEFINED);
94
95        ActionMonitor.registerActionMonitor(mAction.actionKey, mMonitor);
96        assertTrue(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
97        assertTrue(ActionMonitor.sActionMonitors.containsValue(mMonitor));
98        assertEquals(ActionMonitor.sActionMonitors.get(mAction.actionKey), mMonitor);
99
100        try {
101            mAction.markStart();
102            fail("Expect assertion when starting from STATE_UNDEFINED");
103        } catch (final IllegalStateException ex){
104        }
105        ActionMonitor.unregisterActionMonitor(mAction.actionKey, mMonitor);
106
107        assertFalse(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
108        assertFalse(ActionMonitor.sActionMonitors.containsValue(mMonitor));
109    }
110
111    public void testActionTransitionsEndToEndWithRequests() {
112        assertEquals("Start state: STATE_CREATED", ActionMonitor.STATE_CREATED,
113                mMonitor.getState());
114
115        ActionMonitor.registerActionMonitor(mAction.actionKey, mMonitor);
116        assertTrue(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
117        assertTrue(ActionMonitor.sActionMonitors.containsValue(mMonitor));
118        assertEquals(ActionMonitor.sActionMonitors.get(mAction.actionKey), mMonitor);
119
120        mAction.markStart();
121
122        verifyState(1, ActionMonitor.STATE_CREATED, ActionMonitor.STATE_QUEUED);
123
124        mAction.markBeginExecute();
125
126        verifyState(2, ActionMonitor.STATE_QUEUED, ActionMonitor.STATE_EXECUTING);
127
128        final Object result = mAction.executeAction();
129        mAction.requestBackgroundWork();
130
131        assertEquals("Check executeAction result", result, executeActionResult);
132
133        mAction.markEndExecute(result);
134
135        verifyState(3, ActionMonitor.STATE_EXECUTING,
136                ActionMonitor.STATE_BACKGROUND_ACTIONS_QUEUED);
137
138        mAction.markBackgroundWorkStarting();
139
140        verifyState(4, ActionMonitor.STATE_BACKGROUND_ACTIONS_QUEUED,
141                ActionMonitor.STATE_EXECUTING_BACKGROUND_ACTION);
142
143        mAction.markBackgroundWorkQueued();
144
145        verifyState(5, ActionMonitor.STATE_EXECUTING_BACKGROUND_ACTION,
146                ActionMonitor.STATE_BACKGROUND_ACTIONS_QUEUED);
147
148        mAction.markBackgroundWorkStarting();
149
150        verifyState(6, ActionMonitor.STATE_BACKGROUND_ACTIONS_QUEUED,
151                ActionMonitor.STATE_EXECUTING_BACKGROUND_ACTION);
152
153        final Bundle response = null;
154
155        mAction.markBackgroundCompletionQueued();
156
157        verifyState(7, ActionMonitor.STATE_EXECUTING_BACKGROUND_ACTION,
158                ActionMonitor.STATE_BACKGROUND_COMPLETION_QUEUED);
159
160        assertTrue(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
161        assertTrue(ActionMonitor.sActionMonitors.containsValue(mMonitor));
162        assertEquals(ActionMonitor.sActionMonitors.get(mAction.actionKey), mMonitor);
163
164        mAction.processBackgroundWorkResponse(response);
165
166        verifyTransition(7, ActionMonitor.STATE_BACKGROUND_COMPLETION_QUEUED,
167                ActionMonitor.STATE_PROCESSING_BACKGROUND_RESPONSE);
168
169        verifyState(9, ActionMonitor.STATE_PROCESSING_BACKGROUND_RESPONSE,
170                ActionMonitor.STATE_COMPLETE);
171
172        assertFalse(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
173        assertFalse(ActionMonitor.sActionMonitors.containsValue(mMonitor));
174    }
175
176    public void testActionTransitionsEndToEndFailsRequests() {
177        assertEquals("Start state: STATE_CREATED", ActionMonitor.STATE_CREATED,
178                mMonitor.getState());
179
180        ActionMonitor.registerActionMonitor(mAction.actionKey, mMonitor);
181        assertTrue(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
182        assertTrue(ActionMonitor.sActionMonitors.containsValue(mMonitor));
183        assertEquals(ActionMonitor.sActionMonitors.get(mAction.actionKey), mMonitor);
184
185        mAction.markStart();
186
187        verifyState(1, ActionMonitor.STATE_CREATED, ActionMonitor.STATE_QUEUED);
188
189        mAction.markBeginExecute();
190
191        verifyState(2, ActionMonitor.STATE_QUEUED, ActionMonitor.STATE_EXECUTING);
192
193        final Object result = mAction.executeAction();
194        mAction.requestBackgroundWork();
195
196        assertEquals("Check executeAction result", result, executeActionResult);
197
198        mAction.markEndExecute(result);
199
200        verifyState(3, ActionMonitor.STATE_EXECUTING,
201                ActionMonitor.STATE_BACKGROUND_ACTIONS_QUEUED);
202
203        mAction.markBackgroundWorkStarting();
204
205        verifyState(4, ActionMonitor.STATE_BACKGROUND_ACTIONS_QUEUED,
206                ActionMonitor.STATE_EXECUTING_BACKGROUND_ACTION);
207
208        mAction.markBackgroundWorkQueued();
209
210        verifyState(5, ActionMonitor.STATE_EXECUTING_BACKGROUND_ACTION,
211                ActionMonitor.STATE_BACKGROUND_ACTIONS_QUEUED);
212
213        mAction.markBackgroundWorkStarting();
214
215        verifyState(6, ActionMonitor.STATE_BACKGROUND_ACTIONS_QUEUED,
216                ActionMonitor.STATE_EXECUTING_BACKGROUND_ACTION);
217
218        assertTrue(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
219        assertTrue(ActionMonitor.sActionMonitors.containsValue(mMonitor));
220        assertEquals(ActionMonitor.sActionMonitors.get(mAction.actionKey), mMonitor);
221
222        mAction.processBackgroundWorkFailure();
223
224        verifyState(7, ActionMonitor.STATE_EXECUTING_BACKGROUND_ACTION,
225                ActionMonitor.STATE_COMPLETE);
226
227        assertFalse(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
228        assertFalse(ActionMonitor.sActionMonitors.containsValue(mMonitor));
229    }
230
231    public void testActionTransitionsEndToEndNoRequests() {
232        assertEquals("Start state: STATE_CREATED", ActionMonitor.STATE_CREATED,
233                mMonitor.getState());
234
235        ActionMonitor.registerActionMonitor(mAction.actionKey, mMonitor);
236        assertTrue(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
237        assertTrue(ActionMonitor.sActionMonitors.containsValue(mMonitor));
238        assertEquals(ActionMonitor.sActionMonitors.get(mAction.actionKey), mMonitor);
239
240        mAction.markStart();
241
242        verifyState(1, ActionMonitor.STATE_CREATED, ActionMonitor.STATE_QUEUED);
243
244        mAction.markBeginExecute();
245
246        verifyState(2, ActionMonitor.STATE_QUEUED, ActionMonitor.STATE_EXECUTING);
247
248        final Object result = mAction.executeAction();
249
250        assertEquals("Check executeAction result", result, executeActionResult);
251
252        assertTrue(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
253        assertTrue(ActionMonitor.sActionMonitors.containsValue(mMonitor));
254        assertEquals(ActionMonitor.sActionMonitors.get(mAction.actionKey), mMonitor);
255
256        mAction.markEndExecute(result);
257
258        verifyState(3, ActionMonitor.STATE_EXECUTING,
259                ActionMonitor.STATE_COMPLETE);
260
261        assertFalse(ActionMonitor.sActionMonitors.containsKey(mAction.actionKey));
262        assertFalse(ActionMonitor.sActionMonitors.containsValue(mMonitor));
263    }
264
265    public static class TestChatAction extends Action implements Parcelable {
266        protected TestChatAction(final String key, final String parameter) {
267            super(key);
268            this.parameter = parameter;
269        }
270
271        public final String parameter;
272
273        /**
274         * Process the action locally - runs on service thread
275         */
276        @Override
277        protected Object executeAction() {
278            assertEquals("Check parameter", parameter, ActionTest.parameter);
279            return executeActionResult;
280        }
281
282        /**
283         * Process the response from the server - runs on service thread
284         */
285        @Override
286        protected Object processBackgroundResponse(final Bundle response) {
287            assertEquals("Check parameter", parameter, ActionTest.parameter);
288            return processResponseResult;
289        }
290
291        /**
292         * Called in case of failures when sending requests - runs on service thread
293         */
294        @Override
295        protected Object processBackgroundFailure() {
296            assertEquals("Check parameter", parameter, ActionTest.parameter);
297            return processFailureResult;
298        }
299
300        private TestChatAction(final Parcel in) {
301            super(in);
302            parameter = in.readString();
303        }
304
305        public static final Parcelable.Creator<TestChatAction> CREATOR
306                = new Parcelable.Creator<TestChatAction>() {
307            @Override
308            public TestChatAction createFromParcel(final Parcel in) {
309                return new TestChatAction(in);
310            }
311
312            @Override
313            public TestChatAction[] newArray(final int size) {
314                return new TestChatAction[size];
315            }
316        };
317
318        @Override
319        public void writeToParcel(final Parcel parcel, final int flags) {
320            writeActionToParcel(parcel, flags);
321            parcel.writeString(parameter);
322        }
323    }
324}
325