mcs/class/Microsoft.Web.Services/Test/Microsoft.Web.Services.Security/KeyIdentifierTest.cs

   1 //
   2 // KeyIdentifierTest.cs - NUnit Test Cases for KeyIdentifier
   3 //
   4 // Author:
   5 //      Sebastien Pouliot (spouliot@motus.com)
   6 //
   7 // (C) 2002, 2003 Motus Technologies Inc. (http://www.motus.com)
   8 //
   9
  10 using NUnit.Framework;
  11 using Microsoft.Web.Services.Security;
  12 using System;
  13 using System.Xml;
  14
  15 namespace MonoTests.MS.Web.Services.Security {
  16
  17         [TestFixture]
  18         public class KeyIdentifierTest : Assertion {
  19
  20                 private static byte[] array = { 0x00 };
  21                 private const string ValueXml = "<wsse:KeyIdentifier xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2002/07/secext\">AA==</wsse:KeyIdentifier>";
  22                 private const string ValueTypeXml = "<wsse:KeyIdentifier xmlns:vt=\"http://www.go-mono.com/\" ValueType=\"vt:mono\" xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2002/07/secext\">AA==</wsse:KeyIdentifier>";
  23                 private const string WellKnownValueTypeXml = "<wsse:KeyIdentifier ValueType=\"wsse:well-known\" xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2002/07/secext\">AA==</wsse:KeyIdentifier>";
  24                 private const string BadCustomValueTypeXml = "<wsse:KeyIdentifier ValueType=\"custom\" xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2002/07/secext\">AA==</wsse:KeyIdentifier>";
  25
  26                 [Test]
  27                 public void ConstructorByteArray ()
  28                 {
  29                         KeyIdentifier ki = new KeyIdentifier (array);
  30                         Assert ("Value", (ki.Value [0] == array [0]));
  31                         AssertNull ("ValueType", ki.ValueType);
  32                 }
  33
  34                 [Test]
  35                 [ExpectedException (typeof (ArgumentNullException))]
  36                 public void ConstructorByteArrayNull ()
  37                 {
  38                         byte[] array = null; // resolve ambiguity
  39                         KeyIdentifier ki = new KeyIdentifier (array);
  40                 }
  41
  42                 private XmlQualifiedName GetQName ()
  43                 {
  44                         return new XmlQualifiedName ("mono", "http://www.go-mono.com/");
  45                 }
  46
  47                 [Test]
  48                 public void ConstructorXmlQualifiedName ()
  49                 {
  50                         KeyIdentifier ki = new KeyIdentifier (array, GetQName ());
  51                         Assert ("Value", (ki.Value [0] == array [0]));
  52                         AssertNotNull ("ValueType", ki.ValueType);
  53                         Assert ("ValueType.IsEmpty", !ki.ValueType.IsEmpty);
  54                         AssertEquals ("ValueType.Name", "mono", ki.ValueType.Name);
  55                         AssertEquals ("ValueType.Namespace", "http://www.go-mono.com/", ki.ValueType.Namespace);
  56                 }
  57
  58                 [Test]
  59                 public void ConstructorXmlQualifiedNameNull ()
  60                 {
  61                         KeyIdentifier ki = new KeyIdentifier (array, null);
  62                         Assert ("Value", (ki.Value [0] == array [0]));
  63                         AssertNull ("ValueType", ki.ValueType);
  64                 }
  65
  66                 [Test]
  67                 [ExpectedException (typeof (ArgumentNullException))]
  68                 public void ConstructorXmlElementNull ()
  69                 {
  70                         XmlElement xel = null; // resolve ambiguity
  71                         KeyIdentifier ki = new KeyIdentifier (xel);
  72                 }
  73
  74                 [Test]
  75                 [ExpectedException (typeof (ArgumentNullException))]
  76                 public void ValueNull ()
  77                 {
  78                         KeyIdentifier ki = new KeyIdentifier (array);
  79                         ki.Value = null;
  80                 }
  81
  82                 [Test]
  83                 public void ValueTypeNull ()
  84                 {
  85                         KeyIdentifier ki = new KeyIdentifier (array);
  86                         ki.ValueType = null;
  87                 }
  88
  89                 [Test]
  90                 public void GetXml_ValueOnly ()
  91                 {
  92                         KeyIdentifier ki = new KeyIdentifier (array);
  93                         XmlDocument doc = new XmlDocument ();
  94                         XmlElement xel = ki.GetXml (doc);
  95                         AssertEquals ("GetXml_ValueOnly", ValueXml, xel.OuterXml);
  96                 }
  97
  98                 [Test]
  99                 public void GetXml_ValueAndValueType ()
 100                 {
 101                         KeyIdentifier ki = new KeyIdentifier (array, GetQName ());
 102                         XmlDocument doc = new XmlDocument ();
 103                         XmlElement xel = ki.GetXml (doc);
 104                         AssertEquals ("GetXml_ValueAndValueType", ValueTypeXml, xel.OuterXml);
 105                 }
 106
 107                 [Test]
 108                 public void GetXml_WellKnownValueType ()
 109                 {
 110                         KeyIdentifier ki = new KeyIdentifier (array, new XmlQualifiedName ("well-known", WSSecurity.NamespaceURI));
 111                         XmlDocument doc = new XmlDocument ();
 112                         XmlElement xel = ki.GetXml (doc);
 113                         AssertEquals ("GetXml_ValueAndValueType", WellKnownValueTypeXml, xel.OuterXml);
 114                 }
 115
 116                 [Test]
 117                 [ExpectedException (typeof (ArgumentNullException))]
 118                 public void GetXmlNull ()
 119                 {
 120                         KeyIdentifier ki = new KeyIdentifier (array);
 121                         ki.GetXml (null);
 122                 }
 123
 124                 [Test]
 125                 public void LoadXml_Value ()
 126                 {
 127                         KeyIdentifier ki = new KeyIdentifier (array);
 128                         XmlDocument doc = new XmlDocument ();
 129                         doc.LoadXml (ValueXml);
 130                         ki.LoadXml (doc.DocumentElement);
 131                         // roundtrip
 132                         XmlElement xel = ki.GetXml (doc);
 133                         AssertEquals ("LoadXml_Value", ValueXml, xel.OuterXml);
 134                 }
 135
 136                 [Test]
 137                 public void LoadXml_ValueType ()
 138                 {
 139                         KeyIdentifier ki = new KeyIdentifier (array);
 140                         XmlDocument doc = new XmlDocument ();
 141                         doc.LoadXml (ValueTypeXml);
 142                         ki.LoadXml (doc.DocumentElement);
 143                         // roundtrip
 144                         XmlElement xel = ki.GetXml (doc);
 145                         AssertEquals ("LoadXml_ValueType", ValueTypeXml, xel.OuterXml);
 146                 }
 147
 148                 [Test]
 149                 public void LoadXml_WellKnownValueType ()
 150                 {
 151                         KeyIdentifier ki = new KeyIdentifier (array);
 152                         XmlDocument doc = new XmlDocument ();
 153                         doc.LoadXml (WellKnownValueTypeXml);
 154                         ki.LoadXml (doc.DocumentElement);
 155                         // roundtrip
 156                         XmlElement xel = ki.GetXml (doc);
 157                         AssertEquals ("LoadXml_ValueType", WellKnownValueTypeXml, xel.OuterXml);
 158                 }
 159
 160                 [Test]
 161                 [ExpectedException (typeof (SecurityFormatException))]
 162                 public void LoadXml_BadCustomValueType ()
 163                 {
 164                         KeyIdentifier ki = new KeyIdentifier (array);
 165                         XmlDocument doc = new XmlDocument ();
 166                         doc.LoadXml (BadCustomValueTypeXml);
 167                         ki.LoadXml (doc.DocumentElement);
 168                         // roundtrip
 169                         XmlElement xel = ki.GetXml (doc);
 170                         AssertEquals ("LoadXml_ValueType", BadCustomValueTypeXml, xel.OuterXml);
 171                 }
 172
 173                 [Test]
 174                 [ExpectedException (typeof (ArgumentException))]
 175                 public void LoadXml_BadLocalName ()
 176                 {
 177                         KeyIdentifier ki = new KeyIdentifier (array);
 178                         XmlDocument doc = new XmlDocument ();
 179                         doc.LoadXml ("<wsse:KeyId xmlns:vt=\"http://www.go-mono.com/\" ValueType=\"vt:mono\" xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2002/07/secext\">AA==</wsse:KeyId>");
 180                         ki.LoadXml (doc.DocumentElement);
 181                 }
 182
 183                 [Test]
 184                 [ExpectedException (typeof (ArgumentException))]
 185                 public void LoadXml_BadNamespace ()
 186                 {
 187                         KeyIdentifier ki = new KeyIdentifier (array);
 188                         XmlDocument doc = new XmlDocument ();
 189                         doc.LoadXml ("<wsse:KeyIdentifier xmlns:vt=\"http://www.go-mono.com/\" ValueType=\"vt:mono\" xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2202/07/secext\">AA==</wsse:KeyIdentifier>");
 190                         ki.LoadXml (doc.DocumentElement);
 191                 }
 192
 193                 [Test]
 194                 [ExpectedException (typeof (ArgumentNullException))]
 195                 public void LoadXmlNull ()
 196                 {
 197                         KeyIdentifier ki = new KeyIdentifier (array);
 198                         ki.LoadXml (null);
 199                 }
 200         }
 201 }