refactor: Move test clientstack setup code out of BasicCircuitTests into OpenSim.Tests.Common.ClientStackHelpers

2 files changed, 266 insertions, 0 deletions

diff --git a/OpenSim/Tests/Common/Helpers/ClientStackHelpers.cs b/OpenSim/Tests/Common/Helpers/ClientStackHelpers.cs
new file mode 100644
index 0000000..33cd8a2
--- /dev/null
+++ b/OpenSim/Tests/Common/Helpers/ClientStackHelpers.cs
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Region.ClientStack.LindenUDP;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Tests.Common
+{
+    /// <summary>
+    /// This class adds full UDP client classes and associated scene presence to scene.
+    /// </summary>
+    /// <remarks>
+    /// This is used for testing client stack code.  For testing other code, use SceneHelper methods instead since
+    /// they operate without the burden of setting up UDP structures which should be unnecessary for testing scene
+    /// code.
+    /// </remarks>
+    public static class ClientStackHelpers
+    {
+        public static ScenePresence AddChildClient(
+            Scene scene, LLUDPServer udpServer, UUID agentId, UUID sessionId, uint circuitCode)
+        {           
+            IPEndPoint testEp = new IPEndPoint(IPAddress.Loopback, 999);
+
+            UseCircuitCodePacket uccp = new UseCircuitCodePacket();
+
+            UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock
+                = new UseCircuitCodePacket.CircuitCodeBlock();
+            uccpCcBlock.Code = circuitCode;
+            uccpCcBlock.ID = agentId;
+            uccpCcBlock.SessionID = sessionId;
+            uccp.CircuitCode = uccpCcBlock;
+
+            byte[] uccpBytes = uccp.ToBytes();
+            UDPPacketBuffer upb = new UDPPacketBuffer(testEp, uccpBytes.Length);
+            upb.DataLength = uccpBytes.Length;  // God knows why this isn't set by the constructor.
+            Buffer.BlockCopy(uccpBytes, 0, upb.Data, 0, uccpBytes.Length);
+
+            AgentCircuitData acd = new AgentCircuitData();
+            acd.AgentID = agentId;
+            acd.SessionID = sessionId;
+
+            scene.AuthenticateHandler.AddNewCircuit(circuitCode, acd);
+
+            udpServer.PacketReceived(upb);
+
+            return scene.GetScenePresence(agentId);
+        }
+
+        public static TestLLUDPServer AddUdpServer(Scene scene)
+        {
+            return AddUdpServer(scene, new IniConfigSource());
+        }
+
+        public static TestLLUDPServer AddUdpServer(Scene scene, IniConfigSource configSource)
+        {
+            uint port = 0;
+            AgentCircuitManager acm = scene.AuthenticateHandler;
+
+            TestLLUDPServer udpServer = new TestLLUDPServer(IPAddress.Any, ref port, 0, false, configSource, acm);
+            udpServer.AddScene(scene);
+
+            return udpServer;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Tests/Common/Mock/TestLLUDPServer.cs b/OpenSim/Tests/Common/Mock/TestLLUDPServer.cs
new file mode 100644
index 0000000..26887c9
--- /dev/null
+++ b/OpenSim/Tests/Common/Mock/TestLLUDPServer.cs
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+using Nini.Config;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Region.ClientStack.LindenUDP;
+
+namespace OpenSim.Tests.Common
+{
+    /// <summary>
+    /// This class enables regression testing of the LLUDPServer by allowing us to intercept outgoing data.
+    /// </summary>
+    public class TestLLUDPServer : LLUDPServer
+    {
+        public List<Packet> PacketsSent { get; private set; }
+
+        public TestLLUDPServer(IPAddress listenIP, ref uint port, int proxyPortOffsetParm, bool allow_alternate_port, IConfigSource configSource, AgentCircuitManager circuitManager)
+            : base(listenIP, ref port, proxyPortOffsetParm, allow_alternate_port, configSource, circuitManager)
+        {
+            PacketsSent = new List<Packet>();
+        }
+
+        public override void SendAckImmediate(IPEndPoint remoteEndpoint, PacketAckPacket ack)
+        {
+            PacketsSent.Add(ack);
+        }
+
+        public override void SendPacket(
+            LLUDPClient udpClient, Packet packet, ThrottleOutPacketType category, bool allowSplitting, UnackedPacketMethod method)
+        {
+            PacketsSent.Add(packet);
+        }
+
+        public void ClientOutgoingPacketHandler(IClientAPI client, bool resendUnacked, bool sendAcks, bool sendPing)
+        {
+            m_resendUnacked = resendUnacked;
+            m_sendAcks = sendAcks;
+            m_sendPing = sendPing;
+
+            ClientOutgoingPacketHandler(client);
+        }
+
+////        /// <summary>
+////        /// The chunks of data to pass to the LLUDPServer when it calls EndReceive
+////        /// </summary>
+////        protected Queue<ChunkSenderTuple> m_chunksToLoad = new Queue<ChunkSenderTuple>();
+//        
+////        protected override void BeginReceive()
+////        {
+////            if (m_chunksToLoad.Count > 0 && m_chunksToLoad.Peek().BeginReceiveException)
+////            {
+////                ChunkSenderTuple tuple = m_chunksToLoad.Dequeue();
+////                reusedEpSender = tuple.Sender;
+////                throw new SocketException();
+////            }
+////        }
+//        
+////        protected override bool EndReceive(out int numBytes, IAsyncResult result, ref EndPoint epSender)
+////        {
+////            numBytes = 0;
+////
+////            //m_log.Debug("Queue size " + m_chunksToLoad.Count);
+////            
+////            if (m_chunksToLoad.Count <= 0)
+////                return false;
+////            
+////            ChunkSenderTuple tuple = m_chunksToLoad.Dequeue();
+////            RecvBuffer = tuple.Data;
+////            numBytes   = tuple.Data.Length;
+////            epSender   = tuple.Sender;
+////            
+////            return true;
+////        }
+//        
+////        public override void SendPacketTo(byte[] buffer, int size, SocketFlags flags, uint circuitcode)
+////        {
+////            // Don't do anything just yet
+////        }
+//        
+//        /// <summary>
+//        /// Signal that this chunk should throw an exception on Socket.BeginReceive()
+//        /// </summary>
+//        /// <param name="epSender"></param>
+//        public void LoadReceiveWithBeginException(EndPoint epSender)
+//        {
+//            ChunkSenderTuple tuple = new ChunkSenderTuple(epSender);
+//            tuple.BeginReceiveException = true;
+//            m_chunksToLoad.Enqueue(tuple);
+//        }
+//        
+//        /// <summary>
+//        /// Load some data to be received by the LLUDPServer on the next receive call
+//        /// </summary>
+//        /// <param name="data"></param>
+//        /// <param name="epSender"></param>
+//        public void LoadReceive(byte[] data, EndPoint epSender)
+//        {
+//            m_chunksToLoad.Enqueue(new ChunkSenderTuple(data, epSender));
+//        }
+//        
+//        /// <summary>
+//        /// Load a packet to be received by the LLUDPServer on the next receive call
+//        /// </summary>
+//        /// <param name="packet"></param>
+//        public void LoadReceive(Packet packet, EndPoint epSender)
+//        {
+//            LoadReceive(packet.ToBytes(), epSender);
+//        }
+//        
+//        /// <summary>
+//        /// Calls the protected asynchronous result method.  This fires out all data chunks currently queued for send
+//        /// </summary>
+//        /// <param name="result"></param>
+//        public void ReceiveData(IAsyncResult result)
+//        {
+//            // Doesn't work the same way anymore
+////            while (m_chunksToLoad.Count > 0)
+////                OnReceivedData(result);
+//        }
+    }
+    
+    /// <summary>
+    /// Record the data and sender tuple
+    /// </summary>
+    public class ChunkSenderTuple
+    {
+        public byte[] Data;
+        public EndPoint Sender;
+        public bool BeginReceiveException;
+        
+        public ChunkSenderTuple(byte[] data, EndPoint sender)
+        {
+            Data = data;
+            Sender = sender;
+        }
+        
+        public ChunkSenderTuple(EndPoint sender)
+        {
+            Sender = sender;
+        }
+    }
+}