1
2
3
4
5
6
7
8
9
10
11 package org.mule.util.store;
12
13 import org.mule.DefaultMuleEvent;
14 import org.mule.DefaultMuleMessage;
15 import org.mule.MessageExchangePattern;
16 import org.mule.api.MuleContext;
17 import org.mule.api.MuleEvent;
18 import org.mule.api.MuleMessage;
19 import org.mule.api.MuleRuntimeException;
20 import org.mule.api.config.MuleConfiguration;
21 import org.mule.api.store.ListableObjectStore;
22 import org.mule.api.store.ObjectStoreException;
23 import org.mule.config.i18n.CoreMessages;
24 import org.mule.session.DefaultMuleSession;
25 import org.mule.util.FileUtils;
26 import org.mule.util.SerializationUtils;
27 import org.mule.util.UUID;
28 import org.mule.util.queue.QueueKey;
29
30 import java.io.File;
31 import java.io.FileOutputStream;
32 import java.io.IOException;
33 import java.io.Serializable;
34 import java.util.List;
35
36 import org.junit.Rule;
37 import org.junit.Test;
38 import org.junit.rules.TemporaryFolder;
39
40 import static org.junit.Assert.assertEquals;
41 import static org.junit.Assert.assertFalse;
42 import static org.junit.Assert.assertNotNull;
43 import static org.junit.Assert.assertTrue;
44 import static org.junit.Assert.fail;
45 import static org.mockito.Mockito.mock;
46 import static org.mockito.Mockito.when;
47
48 public class QueuePersistenceObjectStoreTestCase extends AbstractObjectStoreContractTestCase
49 {
50 private static final String QUEUE_NAME = "the-queue";
51
52 @Rule
53 public TemporaryFolder tempFolder = new TemporaryFolder();
54
55 private File persistenceFolder;
56 private MuleContext mockMuleContext;
57
58 @Override
59 protected void doSetUp() throws Exception
60 {
61 super.doSetUp();
62 initMockMuleContext();
63 }
64
65 private void initMockMuleContext()
66 {
67 persistenceFolder = tempFolder.newFolder("persistence");
68
69 MuleConfiguration mockConfig = mock(MuleConfiguration.class);
70 when(mockConfig.getWorkingDirectory()).thenReturn(persistenceFolder.getAbsolutePath());
71
72 mockMuleContext = mock(MuleContext.class);
73 when(mockMuleContext.getConfiguration()).thenReturn(mockConfig);
74 when(mockMuleContext.getExecutionClassLoader()).thenReturn(getClass().getClassLoader());
75 when(mockMuleContext.getExecutionClassLoader()).thenReturn(getClass().getClassLoader());
76 }
77
78 @Override
79 public QueuePersistenceObjectStore<Serializable> getObjectStore() throws ObjectStoreException
80 {
81 QueuePersistenceObjectStore<Serializable> store =
82 new QueuePersistenceObjectStore<Serializable>(mockMuleContext);
83 store.open();
84 return store;
85 }
86
87 @Override
88 public Serializable getStorableValue()
89 {
90 return new DefaultMuleMessage(TEST_MESSAGE, muleContext);
91 }
92
93 @Override
94 protected Serializable createKey()
95 {
96 return new QueueKey("theQueue", UUID.getUUID());
97 }
98
99 @Test
100 public void testCreatingTheObjectStoreThrowsMuleRuntimeException()
101 {
102 MuleRuntimeException muleRuntimeException = new MuleRuntimeException(CoreMessages.createStaticMessage("boom"));
103
104 MuleContext mockContext = mock(MuleContext.class);
105 when(mockContext.getConfiguration()).thenThrow(muleRuntimeException);
106
107 QueuePersistenceObjectStore<Serializable> store =
108 new QueuePersistenceObjectStore<Serializable>(mockContext);
109
110 try
111 {
112 store.open();
113 fail();
114 }
115 catch (ObjectStoreException ose)
116 {
117
118 }
119 }
120
121 @Test
122 public void testAllKeysOnNotYetOpenedStore() throws ObjectStoreException
123 {
124 QueuePersistenceObjectStore<Serializable> store =
125 new QueuePersistenceObjectStore<Serializable>(mockMuleContext);
126
127 List<Serializable> allKeys = store.allKeys();
128 assertEquals(0, allKeys.size());
129 }
130
131 @Test
132 public void testListExistingFiles() throws Exception
133 {
134 String id = UUID.getUUID();
135 File storeFile = createStoreFile(id);
136 FileUtils.touch(storeFile);
137
138 QueuePersistenceObjectStore<Serializable> store = getObjectStore();
139
140 List<Serializable> allKeys = store.allKeys();
141 assertEquals(1, allKeys.size());
142
143 QueueKey key = (QueueKey)allKeys.get(0);
144 assertEquals(id, key.id);
145 }
146
147 @Test
148 public void testRetrieveFileFromDisk() throws Exception
149 {
150
151 QueuePersistenceObjectStore<Serializable> store = getObjectStore();
152
153 String id = UUID.getUUID();
154 createAndPopulateStoreFile(id, TEST_MESSAGE);
155
156 QueueKey key = new QueueKey(QUEUE_NAME, id);
157 Serializable value = store.retrieve(key);
158 assertEquals(TEST_MESSAGE, value);
159 }
160
161 @Test
162 public void testRemove() throws Exception
163 {
164
165 QueuePersistenceObjectStore<Serializable> store = getObjectStore();
166
167 String id = UUID.getUUID();
168 File storeFile = createAndPopulateStoreFile(id, TEST_MESSAGE);
169
170 QueueKey key = new QueueKey(QUEUE_NAME, id);
171 store.remove(key);
172
173 assertFalse(storeFile.exists());
174 }
175
176 @Test
177 public void testMonitoredWrapper() throws Exception
178 {
179 QueuePersistenceObjectStore<Serializable> store = getObjectStore();
180 String id = UUID.getUUID();
181 QueueKey key = new QueueKey(QUEUE_NAME, id);
182 MuleMessage msg = new DefaultMuleMessage("Hello", mockMuleContext);
183 MuleEvent event = new DefaultMuleEvent(msg, MessageExchangePattern.ONE_WAY, new DefaultMuleSession(mockMuleContext));
184
185 ListableObjectStore<Serializable> monitored = new MonitoredObjectStoreWrapper(store);
186 monitored.store(key, event);
187 MonitoredObjectStoreWrapper.StoredObject retrieved = (MonitoredObjectStoreWrapper.StoredObject) store.retrieve(key);
188 Object item = retrieved.getItem();
189 assertTrue(item instanceof MuleEvent);
190 MuleEvent newEvent = (MuleEvent) item;
191 MuleMessage newMessage = newEvent.getMessage();
192 assertNotNull(newMessage);
193 assertEquals(mockMuleContext, newMessage.getMuleContext());
194 assertEquals("Hello", newMessage.getPayload());
195 }
196
197 private File createAndPopulateStoreFile(String id, String payload) throws IOException
198 {
199 File storeFile = createStoreFile(id);
200
201
202 storeFile.getParentFile().mkdir();
203
204 FileOutputStream fos = new FileOutputStream(storeFile);
205 SerializationUtils.serialize(payload, fos);
206
207 return storeFile;
208 }
209
210 private File createStoreFile(String id)
211 {
212 String path = String.format("%1s/%2s/%3s/%4s.msg", persistenceFolder.getAbsolutePath(),
213 QueuePersistenceObjectStore.DEFAULT_QUEUE_STORE, QUEUE_NAME, id);
214 return FileUtils.newFile(path);
215 }
216 }