    1   /***
    2    *
    3    * Copyright 2004 Protique Ltd
    4    *
    5    * Licensed under the Apache License, Version 2.0 (the "License");
    6    * you may not use this file except in compliance with the License.
    7    * You may obtain a copy of the License at
    8    *
    9    * http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   *
    17   **/
    18  package org.codehaus.activemq.service;
    19
    20  import junit.framework.TestCase;
    21  import org.codehaus.activemq.message.ActiveMQMessage;
    22  import org.codehaus.activemq.message.ActiveMQTextMessage;
    23  import org.codehaus.activemq.message.MessageAck;
    24  import org.codehaus.activemq.store.PersistenceAdapter;
    25  import org.codehaus.activemq.util.Callback;
    26  import org.codehaus.activemq.util.IdGenerator;
    27  import org.codehaus.activemq.util.TimedTransactionTemplate;
    28  import org.codehaus.activemq.util.TransactionTemplate;
    29
    30  import javax.jms.JMSException;
    31
    32  /***
    33   * @version $Revision: 1.21 $
    34   */
    35  public abstract class MessageContainerTestSupport extends TestCase {
    36      protected MessageContainer container;
    37      protected int messageCount = 50;
    38      protected IdGenerator idGenerator = new IdGenerator();
    39      protected String[] messageIds;
    40      protected MessageIdentity[] messageIdenties;
    41      private String[] messageTexts;
    42      protected PersistenceAdapter persistenceAdapter;
    43      protected boolean topic = false;
    44      private String destinationName;
    45      protected TransactionTemplate transactionTemplate;
    46
    47      public void testWriteLoop() throws Exception {
    48          transactionTemplate.run(new Callback() {
    49              public void execute() throws Throwable {
    50                  writeMessage(0);
    51
    52                  // lets delete using a String which should cause a warning
    53                  MessageIdentity messageIdentity = new MessageIdentity(messageIds[0]);
    54                  container.delete(messageIdentity, createMessageAck(messageIdentity));
    55              }
    56          });
    57
    58          System.out.println("About to write: " + messageCount + " messages to the container: " + container);
    59
    60          transactionTemplate.run(new Callback() {
    61              public void execute() throws Throwable {
    62                  for (int i = 0; i < messageCount; i++) {
    63                      writeMessage(i + 1);
    64                  }
    65              }
    66          });
    67
    68
    69          System.out.println("About to read: " + messageCount + " messages");
    70
    71          transactionTemplate.run(new Callback() {
    72              public void execute() throws Throwable {
    73                  for (int i = 0; i < messageCount; i++) {
    74                      readMessage(i + 1);
    75                  }
    76              }
    77          });
    78
    79          System.out.println("About to delete: " + messageCount + " messages");
    80
    81          transactionTemplate.run(new Callback() {
    82              public void execute() throws Throwable {
    83                  for (int i = 0; i < messageCount; i++) {
    84                      deleteMessage(i + 1);
    85                  }
    86              }
    87          });
    88
    89          if (!topic) {
    90              System.out.println("About to check that all the messages are consumed");
    91              transactionTemplate.run(new Callback() {
    92                  public void execute() throws Throwable {
    93                      for (int i = 0; i < messageCount; i++) {
    94                          assertNoMessage(i + 1);
    95                      }
    96                  }
    97              });
    98          }
    99      }
    100
    101     // Implementation methods
    102     //-------------------------------------------------------------------------
    103     public String getDestinationName() {
    104         if (destinationName == null) {
    105             destinationName = getClass().getName() + "." + getName();
    106         }
    107         return destinationName;
    108     }
    109
    110     public void setDestinationName(String destinationName) {
    111         this.destinationName = destinationName;
    112     }
    113
    114     protected long startUnitOfWork() throws Exception {
    115         return System.currentTimeMillis();
    116     }
    117
    118     protected long endUnitOfWork() throws Exception {
    119         return System.currentTimeMillis();
    120     }
    121
    122     protected void setUp() throws Exception {
    123         super.setUp();
    124         String value = System.getProperty("messageCount");
    125         if (value != null) {
    126             messageCount = Integer.parseInt(value);
    127         }
    128         messageIds = new String[messageCount + 1];
    129         messageTexts = new String[messageCount + 1];
    130         messageIdenties = new MessageIdentity[messageCount + 1];
    131         persistenceAdapter = createPersistenceAdapter();
    132         persistenceAdapter.start();
    133
    134         transactionTemplate = new TimedTransactionTemplate(persistenceAdapter, messageCount);
    135
    136         container = createContainer();
    137         assertTrue("Should have created a container: " + container != null);
    138         container.start();
    139     }
    140
    141     protected void tearDown() throws Exception {
    142         super.tearDown();
    143
    144         if (container != null) {
    145             container.stop();
    146         }
    147
    148         persistenceAdapter.stop();
    149     }
    150
    151     protected MessageContainer createContainer() throws JMSException {
    152         if (topic) {
    153             return persistenceAdapter.createTopicMessageContainer(getDestinationName());
    154         }
    155         else {
    156             return persistenceAdapter.createQueueMessageContainer(getDestinationName());
    157
    158         }
    159     }
    160
    161     protected PersistenceAdapter createPersistenceAdapter() throws Exception {
    162         assertTrue("Must overload this method to create a PersistenceAdapater", false);
    163         return null;
    164     }
    165
    166
    167     protected void writeMessage(int i) throws JMSException {
    168         ActiveMQMessage message = createMessage(i);
    169         String id = idGenerator.generateId();
    170         messageIds[i] = id;
    171         message.setJMSMessageID(id);
    172         messageIdenties[i] = container.addMessage(message);
    173     }
    174
    175     protected void readMessage(int i) throws JMSException {
    176         ActiveMQTextMessage message = (ActiveMQTextMessage) container.getMessage(messageIdenties[i]);
    177         assertTrue("Message should not be null", message != null);
    178
    179         String text = message.getText();
    180         assertEquals("Message text should be equal", messageTexts[i], text);
    181     }
    182
    183     protected MessageAck createMessageAck(MessageIdentity messageIdentity) {
    184         MessageAck answer = new MessageAck();
    185         answer.setConsumerId(idGenerator.generateId());
    186         answer.setMessageID(messageIdentity.getMessageID());
    187         answer.setMessageRead(true);
    188         return answer;
    189     }
    190
    191     protected void deleteMessage(int i) throws JMSException {
    192         container.delete(messageIdenties[i], createMessageAck(messageIdenties[i]));
    193     }
    194
    195     protected void assertNoMessage(int i) throws JMSException {
    196         ActiveMQMessage message = container.getMessage(messageIdenties[i]);
    197         assertTrue("Message should be null", message == null);
    198     }
    199
    200     protected ActiveMQMessage createMessage(int i) throws JMSException {
    201         ActiveMQTextMessage answer = new ActiveMQTextMessage();
    202         String text = "Message: " + i;
    203         messageTexts[i] = text;
    204         answer.setText(text);
    205         return answer;
    206     }
    207 }