test/nms-api-test/URISupportTest.cs - activemq-nms-api - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (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.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 using System;
 using System.Collections.Specialized;
 using Apache.NMS.Util;
 using NUnit.Framework;
 #if !NETCF
 using System.Web;

 #endif

 namespace Apache.NMS.Test
 {
     [TestFixture()]
     public class URISupportTest
     {
         protected void AssertMapKey(StringDictionary map, String key, Object expected)
         {
             Assert.AreEqual(expected, map[key], "Map key: " + key);
         }

         [Test]
         public void TestCreateSupportedUriVariations(
             [Values("tcp://127.0.0.1:61616",
                 "tcp:127.0.0.1:61616",
                 "failover:tcp://127.0.0.1:61616",
                 "failover:(tcp://127.0.0.1:61616)",
                 "failover://(tcp://127.0.0.1:61616)",
                 "failover://(tcp://127.0.0.1:61616,tcp:192.168.0.1:61616)",
                 "activemq:failover:(tcp://localhost:61616)",
                 "activemq:failover:(tcp://${activemqhost}:61616)")]
             string uriString)
         {
             Uri result = URISupport.CreateCompatibleUri(NMSTestSupport.ReplaceEnvVar(uriString));

             Assert.IsNotNull(result);
         }

         [Test]
         public void TestParseCompositeWithFragment()
         {
             string uriString =
                 "failover:(tcp://localhost:61616,ssl://remotehost:61617?param=true#fragment)#fragment";

             URISupport.CompositeData rc = URISupport.ParseComposite(new Uri(uriString));

             Assert.IsTrue(rc.Components.Length == 2);
             Assert.AreEqual("failover", rc.Scheme);
             Assert.AreEqual("#fragment", rc.Fragment);

             Uri uri1 = rc.Components[0];
             Uri uri2 = rc.Components[1];

             Assert.AreEqual("tcp", uri1.Scheme);
             Assert.AreEqual("ssl", uri2.Scheme);
             Assert.AreEqual("localhost", uri1.Host);
             Assert.AreEqual("remotehost", uri2.Host);
             Assert.AreEqual(61616, uri1.Port);
             Assert.AreEqual(61617, uri2.Port);
             Assert.IsTrue(String.IsNullOrEmpty(uri1.Fragment));
             Assert.IsNotNull(uri2.Fragment);
             Assert.AreEqual("#fragment", uri2.Fragment);
             Assert.AreEqual("?param=true", uri2.Query);
         }

         [Test]
         public void TestCreateRemainingUriNonComposite()
         {
             string uriStringNoParams = "tcp://localhost:61616";
             string uriStringWithParams1 = "tcp://localhost:61616?param1=true&param2=false";
             string uriStringWithParams2 = "tcp://localhost:61616?param2=false&param1=true";

             Uri uriNoParams = new Uri(uriStringNoParams);
             Uri uriWithParams1 = new Uri(uriStringWithParams1);

             Uri result = URISupport.CreateRemainingUri(uriNoParams, null);
             Assert.AreEqual(uriStringNoParams, result.OriginalString);

             result = URISupport.CreateRemainingUri(uriWithParams1, null);
             Assert.AreEqual(uriStringNoParams, result.OriginalString);

             StringDictionary parameters = new StringDictionary();
             parameters.Add("param1", "true");
             parameters.Add("param2", "false");

             result = URISupport.CreateRemainingUri(uriNoParams, parameters);
             // Have to test for reordering of parameters.  The StringDictionary that is used internally
             // does not guarantee ordering of parameters.  Out of order parameters are equivalent.
             // We just want to test that they were created successfully.
             bool isEqual = (0 == string.Compare(uriStringWithParams1, result.OriginalString)
                             || 0 == string.Compare(uriStringWithParams2, result.OriginalString));
             Assert.IsTrue(isEqual, string.Format("Error creating remaining Uri: {0}", result.OriginalString));
         }

         [Test]
         public void TestCreateRemainingUriComposite()
         {
             string uriStringNoParams = "failover:tcp://localhost:61616";
             string uriStringWithParams1 = "failover:tcp://localhost:61616?param1=true&param2=false";
             string uriStringWithParams2 = "failover:tcp://localhost:61616?param2=false&param1=true";

             Uri uriNoParams = new Uri(uriStringNoParams);
             Uri uriWithParams = new Uri(uriStringWithParams1);

             Uri result = URISupport.CreateRemainingUri(uriNoParams, null);
             Assert.AreEqual(uriStringNoParams, result.OriginalString);

             result = URISupport.CreateRemainingUri(uriWithParams, null);
             Assert.AreEqual(uriStringNoParams, result.OriginalString);

             StringDictionary parameters = new StringDictionary();
             parameters.Add("param1", "true");
             parameters.Add("param2", "false");

             result = URISupport.CreateRemainingUri(uriNoParams, parameters);
             bool isEqual = (0 == string.Compare(uriStringWithParams1, result.OriginalString)
                             || 0 == string.Compare(uriStringWithParams2, result.OriginalString));
             Assert.IsTrue(isEqual, string.Format("Error creating remaining Uri: {0}", result.OriginalString));

             // Now test a Composite with parens.

             uriStringNoParams = "failover:(tcp://localhost:61616)";
             uriStringWithParams1 = "failover:(tcp://localhost:61616)?param1=true&param2=false";
             uriStringWithParams2 = "failover:(tcp://localhost:61616)?param2=false&param1=true";

             uriNoParams = new Uri(uriStringNoParams);
             uriWithParams = new Uri(uriStringWithParams1);

             result = URISupport.CreateRemainingUri(uriNoParams, null);
             Assert.AreEqual(uriStringNoParams, result.OriginalString);

             result = URISupport.CreateRemainingUri(uriWithParams, null);
             Assert.AreEqual(uriStringNoParams, result.OriginalString);

             result = URISupport.CreateRemainingUri(uriNoParams, parameters);
             isEqual = (0 == string.Compare(uriStringWithParams1, result.OriginalString)
                        || 0 == string.Compare(uriStringWithParams2, result.OriginalString));
             Assert.IsTrue(isEqual, string.Format("Error creating remaining Uri: {0}", result.OriginalString));

             string queryString = URISupport.CreateQueryString(parameters);
             Assert.AreEqual(uriNoParams.OriginalString + "?" + queryString, result.OriginalString);
         }

         [Test]
         public void TestEmptyCompositePath()
         {
             URISupport.CompositeData data = URISupport.ParseComposite(new Uri("broker:()/localhost?persistent=false"));
             Assert.AreEqual(0, data.Components.Length);
         }

         [Test]
         public void TestCompositePath()
         {
             URISupport.CompositeData data = URISupport.ParseComposite(new Uri("test:(test:path)/path"));
             Assert.AreEqual("path", data.Path);
             data = URISupport.ParseComposite(new Uri("test:test:path"));
             Assert.IsNull(data.Path);
         }

         [Test]
         public void TestSimpleComposite()
         {
             URISupport.CompositeData data = URISupport.ParseComposite(new Uri("test:tcp://part1"));
             Assert.AreEqual(1, data.Components.Length);
         }

         [Test]
         public void TestComposite()
         {
             URISupport.CompositeData data = URISupport.ParseComposite(
                 new Uri("test:(part1://host,part2://(sub1://part,sub2:part))"));
             Assert.AreEqual(2, data.Components.Length);
         }

         [Test]
         public void TestCompositeWithComponentParam()
         {
             URISupport.CompositeData data =
                 URISupport.ParseComposite(new Uri("test:(part1://host?part1=true)?outside=true"));
             Assert.AreEqual(1, data.Components.Length);
             Assert.AreEqual(1, data.Parameters.Count);
             StringDictionary part1Params = URISupport.ParseParameters(data.Components[0]);
             Assert.AreEqual(1, part1Params.Count);
             Assert.IsTrue(part1Params.ContainsKey("part1"));
         }

         [Test]
         public void TestParsingURI()
         {
             Uri source = new Uri("tcp://localhost:61626/foo/bar?cheese=Edam&x=123");
             StringDictionary map = URISupport.ParseParameters(source);

             Assert.AreEqual(2, map.Count, "Size: " + map);
             AssertMapKey(map, "cheese", "Edam");
             AssertMapKey(map, "x", "123");

             Uri result = URISupport.RemoveQuery(source);
             Assert.AreEqual(new Uri("tcp://localhost:61626/foo/bar"), result);
         }

         [Test]
         public void TestParsingCompositeURI()
         {
             URISupport.CompositeData data = URISupport.ParseComposite(
                 URISupport.CreateCompatibleUri("failover://(tcp://localhost:61616)?name=foo"));

             Assert.AreEqual(1, data.Components.Length, "one component");
             Assert.AreEqual("localhost", data.Components[0].Host, "Component Host is incorrect");
             Assert.AreEqual(61616, data.Components[0].Port, "Component Port is incorrect");
             Assert.AreEqual(1, data.Parameters.Count, "Size: " + data.Parameters);
         }

         [Test]
         public void TestCheckParenthesis()
         {
             String str = "fred:(((ddd))";
             Assert.IsFalse(URISupport.CheckParenthesis(str));
             str += ")";
             Assert.IsTrue(URISupport.CheckParenthesis(str));
         }

         [Test]
         public void TestParseQueury()
         {
             String query1 = "?param1=false&param2=true";
             String query2 = "param3=false&param4=true&param5=foo";

             StringDictionary results = URISupport.ParseQuery(query1);

             Assert.IsTrue(results.Count == 2);
             Assert.AreEqual("false", results["param1"]);
             Assert.AreEqual("true", results["param2"]);

             results = URISupport.ParseQuery(query2);

             Assert.IsTrue(results.Count == 3);
             Assert.AreEqual("false", results["param3"]);
             Assert.AreEqual("true", results["param4"]);
             Assert.AreEqual("foo", results["param5"]);

             String query3 = "?param";

             try
             {
                 URISupport.ParseQuery(query3);
                 Assert.Fail("Should have thrown an Exception on invalid parameter.");
             }
             catch
             {
             }
         }

         [Test]
         public void TestCreateWithQuery()
         {
             Uri source = new Uri("vm://localhost");
             Uri dest = URISupport.CreateUriWithQuery(source, "network=true&one=two");

             Assert.AreEqual(2, URISupport.ParseParameters(dest).Count, "correct param count");
             Assert.AreEqual(source.Host, dest.Host, "same uri, host");
             Assert.AreEqual(source.Scheme, dest.Scheme, "same uri, scheme");
             Assert.IsFalse(dest.Query.Equals(source.Query), "same uri, ssp");
         }

 #if !NETCF
         [Test]
         public void TestParseQueryEncoding()
         {
             String paramName = "name";
             String paramValue = "CN=Test, OU=bla, ..&%/§()%3q743847)/(&%/.. hjUIFHUFH";

             String uriString = "http://someserver.com:1234/?";

             //encoding the param with url encode
             uriString += paramName + "=" + HttpUtility.UrlEncode(paramValue);

             Uri uri = new Uri(uriString);

             StringDictionary dictionary = URISupport.ParseQuery(uri.Query);

             String value = dictionary[paramName];

             NUnit.Framework.Assert.AreEqual(paramValue, value);
         }
 #endif
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (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.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	using System;
	using System.Collections.Specialized;
	using Apache.NMS.Util;
	using NUnit.Framework;
	#if !NETCF
	using System.Web;

	#endif

	namespace Apache.NMS.Test
	{
	[TestFixture()]
	public class URISupportTest
	{
	protected void AssertMapKey(StringDictionary map, String key, Object expected)
	{
	Assert.AreEqual(expected, map[key], "Map key: " + key);
	}

	[Test]
	public void TestCreateSupportedUriVariations(
	[Values("tcp://127.0.0.1:61616",
	"tcp:127.0.0.1:61616",
	"failover:tcp://127.0.0.1:61616",
	"failover:(tcp://127.0.0.1:61616)",
	"failover://(tcp://127.0.0.1:61616)",
	"failover://(tcp://127.0.0.1:61616,tcp:192.168.0.1:61616)",
	"activemq:failover:(tcp://localhost:61616)",
	"activemq:failover:(tcp://${activemqhost}:61616)")]
	string uriString)
	{
	Uri result = URISupport.CreateCompatibleUri(NMSTestSupport.ReplaceEnvVar(uriString));

	Assert.IsNotNull(result);
	}

	[Test]
	public void TestParseCompositeWithFragment()
	{
	string uriString =
	"failover:(tcp://localhost:61616,ssl://remotehost:61617?param=true#fragment)#fragment";

	URISupport.CompositeData rc = URISupport.ParseComposite(new Uri(uriString));

	Assert.IsTrue(rc.Components.Length == 2);
	Assert.AreEqual("failover", rc.Scheme);
	Assert.AreEqual("#fragment", rc.Fragment);

	Uri uri1 = rc.Components[0];
	Uri uri2 = rc.Components[1];

	Assert.AreEqual("tcp", uri1.Scheme);
	Assert.AreEqual("ssl", uri2.Scheme);
	Assert.AreEqual("localhost", uri1.Host);
	Assert.AreEqual("remotehost", uri2.Host);
	Assert.AreEqual(61616, uri1.Port);
	Assert.AreEqual(61617, uri2.Port);
	Assert.IsTrue(String.IsNullOrEmpty(uri1.Fragment));
	Assert.IsNotNull(uri2.Fragment);
	Assert.AreEqual("#fragment", uri2.Fragment);
	Assert.AreEqual("?param=true", uri2.Query);
	}

	[Test]
	public void TestCreateRemainingUriNonComposite()
	{
	string uriStringNoParams = "tcp://localhost:61616";
	string uriStringWithParams1 = "tcp://localhost:61616?param1=true&param2=false";
	string uriStringWithParams2 = "tcp://localhost:61616?param2=false&param1=true";

	Uri uriNoParams = new Uri(uriStringNoParams);
	Uri uriWithParams1 = new Uri(uriStringWithParams1);

	Uri result = URISupport.CreateRemainingUri(uriNoParams, null);
	Assert.AreEqual(uriStringNoParams, result.OriginalString);

	result = URISupport.CreateRemainingUri(uriWithParams1, null);
	Assert.AreEqual(uriStringNoParams, result.OriginalString);

	StringDictionary parameters = new StringDictionary();
	parameters.Add("param1", "true");
	parameters.Add("param2", "false");

	result = URISupport.CreateRemainingUri(uriNoParams, parameters);
	// Have to test for reordering of parameters. The StringDictionary that is used internally
	// does not guarantee ordering of parameters. Out of order parameters are equivalent.
	// We just want to test that they were created successfully.
	bool isEqual = (0 == string.Compare(uriStringWithParams1, result.OriginalString)
	\|\| 0 == string.Compare(uriStringWithParams2, result.OriginalString));
	Assert.IsTrue(isEqual, string.Format("Error creating remaining Uri: {0}", result.OriginalString));
	}

	[Test]
	public void TestCreateRemainingUriComposite()
	{
	string uriStringNoParams = "failover:tcp://localhost:61616";
	string uriStringWithParams1 = "failover:tcp://localhost:61616?param1=true&param2=false";
	string uriStringWithParams2 = "failover:tcp://localhost:61616?param2=false&param1=true";

	Uri uriNoParams = new Uri(uriStringNoParams);
	Uri uriWithParams = new Uri(uriStringWithParams1);

	Uri result = URISupport.CreateRemainingUri(uriNoParams, null);
	Assert.AreEqual(uriStringNoParams, result.OriginalString);

	result = URISupport.CreateRemainingUri(uriWithParams, null);
	Assert.AreEqual(uriStringNoParams, result.OriginalString);

	StringDictionary parameters = new StringDictionary();
	parameters.Add("param1", "true");
	parameters.Add("param2", "false");

	result = URISupport.CreateRemainingUri(uriNoParams, parameters);
	bool isEqual = (0 == string.Compare(uriStringWithParams1, result.OriginalString)
	\|\| 0 == string.Compare(uriStringWithParams2, result.OriginalString));
	Assert.IsTrue(isEqual, string.Format("Error creating remaining Uri: {0}", result.OriginalString));

	// Now test a Composite with parens.

	uriStringNoParams = "failover:(tcp://localhost:61616)";
	uriStringWithParams1 = "failover:(tcp://localhost:61616)?param1=true&param2=false";
	uriStringWithParams2 = "failover:(tcp://localhost:61616)?param2=false&param1=true";

	uriNoParams = new Uri(uriStringNoParams);
	uriWithParams = new Uri(uriStringWithParams1);

	result = URISupport.CreateRemainingUri(uriNoParams, null);
	Assert.AreEqual(uriStringNoParams, result.OriginalString);

	result = URISupport.CreateRemainingUri(uriWithParams, null);
	Assert.AreEqual(uriStringNoParams, result.OriginalString);

	result = URISupport.CreateRemainingUri(uriNoParams, parameters);
	isEqual = (0 == string.Compare(uriStringWithParams1, result.OriginalString)
	\|\| 0 == string.Compare(uriStringWithParams2, result.OriginalString));
	Assert.IsTrue(isEqual, string.Format("Error creating remaining Uri: {0}", result.OriginalString));

	string queryString = URISupport.CreateQueryString(parameters);
	Assert.AreEqual(uriNoParams.OriginalString + "?" + queryString, result.OriginalString);
	}

	[Test]
	public void TestEmptyCompositePath()
	{
	URISupport.CompositeData data = URISupport.ParseComposite(new Uri("broker:()/localhost?persistent=false"));
	Assert.AreEqual(0, data.Components.Length);
	}

	[Test]
	public void TestCompositePath()
	{
	URISupport.CompositeData data = URISupport.ParseComposite(new Uri("test:(test:path)/path"));
	Assert.AreEqual("path", data.Path);
	data = URISupport.ParseComposite(new Uri("test:test:path"));
	Assert.IsNull(data.Path);
	}

	[Test]
	public void TestSimpleComposite()
	{
	URISupport.CompositeData data = URISupport.ParseComposite(new Uri("test:tcp://part1"));
	Assert.AreEqual(1, data.Components.Length);
	}

	[Test]
	public void TestComposite()
	{
	URISupport.CompositeData data = URISupport.ParseComposite(
	new Uri("test:(part1://host,part2://(sub1://part,sub2:part))"));
	Assert.AreEqual(2, data.Components.Length);
	}

	[Test]
	public void TestCompositeWithComponentParam()
	{
	URISupport.CompositeData data =
	URISupport.ParseComposite(new Uri("test:(part1://host?part1=true)?outside=true"));
	Assert.AreEqual(1, data.Components.Length);
	Assert.AreEqual(1, data.Parameters.Count);
	StringDictionary part1Params = URISupport.ParseParameters(data.Components[0]);
	Assert.AreEqual(1, part1Params.Count);
	Assert.IsTrue(part1Params.ContainsKey("part1"));
	}

	[Test]
	public void TestParsingURI()
	{
	Uri source = new Uri("tcp://localhost:61626/foo/bar?cheese=Edam&x=123");
	StringDictionary map = URISupport.ParseParameters(source);

	Assert.AreEqual(2, map.Count, "Size: " + map);
	AssertMapKey(map, "cheese", "Edam");
	AssertMapKey(map, "x", "123");

	Uri result = URISupport.RemoveQuery(source);
	Assert.AreEqual(new Uri("tcp://localhost:61626/foo/bar"), result);
	}

	[Test]
	public void TestParsingCompositeURI()
	{
	URISupport.CompositeData data = URISupport.ParseComposite(
	URISupport.CreateCompatibleUri("failover://(tcp://localhost:61616)?name=foo"));

	Assert.AreEqual(1, data.Components.Length, "one component");
	Assert.AreEqual("localhost", data.Components[0].Host, "Component Host is incorrect");
	Assert.AreEqual(61616, data.Components[0].Port, "Component Port is incorrect");
	Assert.AreEqual(1, data.Parameters.Count, "Size: " + data.Parameters);
	}

	[Test]
	public void TestCheckParenthesis()
	{
	String str = "fred:(((ddd))";
	Assert.IsFalse(URISupport.CheckParenthesis(str));
	str += ")";
	Assert.IsTrue(URISupport.CheckParenthesis(str));
	}

	[Test]
	public void TestParseQueury()
	{
	String query1 = "?param1=false&param2=true";
	String query2 = "param3=false&param4=true&param5=foo";

	StringDictionary results = URISupport.ParseQuery(query1);

	Assert.IsTrue(results.Count == 2);
	Assert.AreEqual("false", results["param1"]);
	Assert.AreEqual("true", results["param2"]);

	results = URISupport.ParseQuery(query2);

	Assert.IsTrue(results.Count == 3);
	Assert.AreEqual("false", results["param3"]);
	Assert.AreEqual("true", results["param4"]);
	Assert.AreEqual("foo", results["param5"]);

	String query3 = "?param";

	try
	{
	URISupport.ParseQuery(query3);
	Assert.Fail("Should have thrown an Exception on invalid parameter.");
	}
	catch
	{
	}
	}

	[Test]
	public void TestCreateWithQuery()
	{
	Uri source = new Uri("vm://localhost");
	Uri dest = URISupport.CreateUriWithQuery(source, "network=true&one=two");

	Assert.AreEqual(2, URISupport.ParseParameters(dest).Count, "correct param count");
	Assert.AreEqual(source.Host, dest.Host, "same uri, host");
	Assert.AreEqual(source.Scheme, dest.Scheme, "same uri, scheme");
	Assert.IsFalse(dest.Query.Equals(source.Query), "same uri, ssp");
	}

	#if !NETCF
	[Test]
	public void TestParseQueryEncoding()
	{
	String paramName = "name";
	String paramValue = "CN=Test, OU=bla, ..&%/§()%3q743847)/(&%/.. hjUIFHUFH";

	String uriString = "http://someserver.com:1234/?";

	//encoding the param with url encode
	uriString += paramName + "=" + HttpUtility.UrlEncode(paramValue);

	Uri uri = new Uri(uriString);

	StringDictionary dictionary = URISupport.ParseQuery(uri.Query);

	String value = dictionary[paramName];

	NUnit.Framework.Assert.AreEqual(paramValue, value);
	}
	#endif
	}
	}