Set up exchanges, queues and bindings for internal exchange test.

Author: Jerry Kuch

src/com/rabbitmq/client/Channel.java

@@ -39,6 +39,7 @@
 import com.rabbitmq.client.AMQP.Tx;
 import com.rabbitmq.client.AMQP.Basic;
 import com.rabbitmq.client.AMQP.Channel.FlowOk;
+import com.rabbitmq.client.impl.AMQImpl;
 
 /**
  * Public API: Interface to an AMQ channel. See the <a href="http://www.amqp.org/">spec</a> for details.
@@ -272,6 +273,29 @@ void basicPublish(String exchange, String routingKey, boolean mandatory, boolean
     Exchange.DeclareOk exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete,
                                        Map<String, Object> arguments) throws IOException;
 
+    /**
+     * Declare an exchange, via an interface that allows the complete set of
+     * arguments.
+     * @see com.rabbitmq.client.AMQP.Exchange.Declare
+     * @see com.rabbitmq.client.AMQP.Exchange.DeclareOk
+     * @param exchange the name of the exchange
+     * @param type the exchange type
+     * @param durable true if we are declaring a durable exchange (the exchange will survive a server restart)
+     * @param autoDelete true if the server should delete the exchange when it is no longer in use
+     * @param internal true if the exchange is internal, i.e. can't be directly
+     * published to by a client.
+     * @param arguments other properties (construction arguments) for the exchange
+     * @return a declaration-confirm method to indicate the exchange was successfully declared
+     * @throws java.io.IOException if an error is encountered
+     */
+    public AMQImpl.Exchange.DeclareOk exchangeDeclare(String exchange,
+                                                      String type,
+                                                      boolean durable,
+                                                      boolean autoDelete,
+                                                      boolean internal,
+                                                      Map<String, Object> arguments)
+            throws IOException;
+
     /**
      * Declare an exchange passively; that is, check if the named exchange exists.
      * @param name check the existence of an exchange named this

src/com/rabbitmq/client/impl/ChannelN.java

@@ -484,6 +484,22 @@ public Exchange.DeclareOk exchangeDeclare(String exchange, String type,
                                                 false, false, arguments)).getMethod();
     }
 
+    /** Public API - {@inheritDoc} */
+    public Exchange.DeclareOk exchangeDeclare(String exchange, String type,
+                                              boolean durable,
+                                              boolean autoDelete,
+                                              boolean internal,
+                                              Map<String, Object> arguments)
+            throws IOException
+    {
+        return (Exchange.DeclareOk)
+                exnWrappingRpc(new Exchange.Declare(TICKET, exchange, type,
+                                                    false, durable, autoDelete,
+                                                    internal, false,
+                                                    arguments)).getMethod();
+    }
+
+
     /** Public API - {@inheritDoc} */
     public Exchange.DeclareOk exchangeDeclare(String exchange, String type,
                                               boolean durable)

test/src/com/rabbitmq/client/test/functional/InternalExchangeTest.java

@@ -0,0 +1,112 @@
+//   The contents of this file are subject to the Mozilla Public License
+//   Version 1.1 (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.mozilla.org/MPL/
+//
+//   Software distributed under the License is distributed on an "AS IS"
+//   basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+//   License for the specific language governing rights and limitations
+//   under the License.
+//
+//   The Original Code is RabbitMQ.
+//
+//   The Initial Developers of the Original Code are LShift Ltd,
+//   Cohesive Financial Technologies LLC, and Rabbit Technologies Ltd.
+//
+//   Portions created before 22-Nov-2008 00:00:00 GMT by LShift Ltd,
+//   Cohesive Financial Technologies LLC, or Rabbit Technologies Ltd
+//   are Copyright (C) 2007-2008 LShift Ltd, Cohesive Financial
+//   Technologies LLC, and Rabbit Technologies Ltd.
+//
+//   Portions created by LShift Ltd are Copyright (C) 2007-2010 LShift
+//   Ltd. Portions created by Cohesive Financial Technologies LLC are
+//   Copyright (C) 2007-2010 Cohesive Financial Technologies
+//   LLC. Portions created by Rabbit Technologies Ltd are Copyright
+//   (C) 2007-2010 Rabbit Technologies Ltd.
+//
+//   All Rights Reserved.
+//
+//   Contributor(s): ______________________________________.
+//
+
+package com.rabbitmq.client.test.functional;
+
+import com.rabbitmq.client.QueueingConsumer;
+import com.rabbitmq.client.test.BrokerTestCase;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+
+//
+// Functional test demonstrating use of an internal exchange in an exchange to
+// exchange routing scenario.  The routing topology is:
+//
+//            -------            -------
+//          -/       \-        -/       \-
+//         /           \      /           \           +-------------+
+//         |    e0     +------|    e1     +-----------+    q1       |
+//         \           /      \           /           +-------------+
+//          -\       /-        -\       /-
+//            -------            -------
+//                              (internal)
+//
+public class InternalExchangeTest extends BrokerTestCase
+{
+    private final String[] queues = new String[] { "q1" };
+    private final String[] exchanges = new String[] { "e0", "e1" };
+
+    private QueueingConsumer[] consumers =
+                                   new QueueingConsumer[] { null, null, null };
+
+    protected void createResources() throws IOException
+    {
+        for (String q : queues)
+        {
+            channel.queueDeclare(q, false, false, false, null);
+        }
+
+        // First exchange will be an 'internal' one.
+        for ( String e : exchanges )
+        {
+            channel.exchangeDeclare(e, "direct",
+                                    false, false,
+                                    e.equals("e0") ? false : true,
+                                    null);
+        }
+
+        channel.exchangeBind("e1", "e0", "");
+        channel.queueBind("q1", "e1", "");
+
+    }
+
+    @Override
+    protected void releaseResources() throws IOException
+    {
+        for (String q : queues)
+        {
+            channel.queueDelete(q);
+        }
+        for (String e : exchanges)
+        {
+            channel.exchangeDelete(e);
+        }
+    }
+
+
+    public void testOhForFucksSake() throws IOException, InterruptedException
+    {
+        System.out.println("Yes, there is a test here.");
+
+        // Create a simple consumer to try to catch stuff we've published...
+        if(false)
+        {
+            QueueingConsumer consumer = new QueueingConsumer(channel);
+            channel.basicConsume("q1", false, consumer);
+
+            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
+            // process delivery
+            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
+        }
+    }
+}