mcs/class/corlib/Test/System.Security.Permissions/PrincipalPermissionTest.cs

   1 //
   2 // PrincipalPermissionTest.cs - NUnit Test Cases for PrincipalPermission
   3 //
   4 // Author:
   5 //      Sebastien Pouliot (spouliot@motus.com)
   6 //
   7 // (C) 2003 Motus Technologies Inc. (http://www.motus.com)
   8 //
   9
  10 using NUnit.Framework;
  11 using System;
  12 using System.Security;
  13 using System.Security.Permissions;
  14
  15 namespace MonoTests.System.Security.Permissions {
  16
  17         [TestFixture]
  18         public class PrincipalPermissionTest : Assertion {
  19
  20                 private static string className = "System.Security.Permissions.PrincipalPermission, ";
  21
  22                 [Test]
  23                 public void PermissionStateNone ()
  24                 {
  25                         PrincipalPermission p = new PrincipalPermission (PermissionState.None);
  26                         AssertNotNull ("PrincipalPermission(PermissionState.None)", p);
  27                         Assert ("IsUnrestricted", !p.IsUnrestricted ());
  28                         PrincipalPermission copy = (PrincipalPermission) p.Copy ();
  29                         AssertEquals ("Copy.IsUnrestricted", p.IsUnrestricted (), copy.IsUnrestricted ());
  30                         SecurityElement se = p.ToXml ();
  31                         Assert ("ToXml-class", (se.Attributes ["class"] as string).StartsWith (className));
  32                         AssertEquals ("ToXml-version", "1", (se.Attributes ["version"] as string));
  33                 }
  34
  35                 [Test]
  36                 public void PermissionStateUnrestricted ()
  37                 {
  38                         PrincipalPermission p = new PrincipalPermission (PermissionState.Unrestricted);
  39                         AssertNotNull ("PrincipalPermission(PermissionState.Unrestricted)", p);
  40                         Assert ("IsUnrestricted", p.IsUnrestricted ());
  41                         PrincipalPermission copy = (PrincipalPermission) p.Copy ();
  42                         AssertEquals ("Copy.IsUnrestricted", p.IsUnrestricted (), copy.IsUnrestricted ());
  43                         // Note: Unrestricted isn't shown in XML
  44                 }
  45
  46                 [Test]
  47                 public void Name ()
  48                 {
  49                         PrincipalPermission p = new PrincipalPermission ("user", null);
  50                         Assert("Name.IsUnrestricted", !p.IsUnrestricted ());
  51                 }
  52
  53                 [Test]
  54                 public void UnauthenticatedName ()
  55                 {
  56                         PrincipalPermission p = new PrincipalPermission ("user", null, false);
  57                         Assert("UnauthenticatedName.IsUnrestricted", !p.IsUnrestricted ());
  58                 }
  59
  60                 [Test]
  61                 public void Role ()
  62                 {
  63                         PrincipalPermission p = new PrincipalPermission (null, "users");
  64                         Assert("Role.IsUnrestricted", !p.IsUnrestricted ());
  65                 }
  66
  67                 [Test]
  68                 public void UnauthenticatedRole ()
  69                 {
  70                         PrincipalPermission p = new PrincipalPermission (null, "users", false);
  71                         Assert("UnauthenticatedRole.IsUnrestricted", !p.IsUnrestricted ());
  72                 }
  73
  74                 [Test]
  75                 public void NameRole ()
  76                 {
  77                         PrincipalPermission p = new PrincipalPermission ("user", "users", true);
  78                         Assert("NameRole.IsUnrestricted", !p.IsUnrestricted ());
  79                 }
  80
  81                 [Test]
  82                 public void UnauthenticatedNameRole ()
  83                 {
  84                         PrincipalPermission p = new PrincipalPermission ("user", "users", false);
  85                         Assert("UnauthenticatedNameRole.IsUnrestricted", !p.IsUnrestricted ());
  86                 }
  87
  88                 [Test]
  89                 public void AuthenticatedNullNull ()
  90                 {
  91                         PrincipalPermission p = new PrincipalPermission (null, null, true);
  92                         Assert("UnauthenticatedNameRole.IsUnrestricted", p.IsUnrestricted ());
  93                 }
  94
  95                 [Test]
  96                 [ExpectedException (typeof (ArgumentNullException))]
  97                 public void FromXmlNull ()
  98                 {
  99                         PrincipalPermission p = new PrincipalPermission (PermissionState.None);
 100                         p.FromXml (null);
 101                 }
 102
 103                 [Test]
 104                 [ExpectedException (typeof (ArgumentException))]
 105                 public void FromXmlInvalidPermission ()
 106                 {
 107                         PrincipalPermission p = new PrincipalPermission (PermissionState.None);
 108                         SecurityElement se = p.ToXml ();
 109                         // can't modify - so we create our own
 110                         SecurityElement se2 = new SecurityElement ("IInvalidPermission", se.Text);
 111                         se2.AddAttribute ("class", se.Attribute ("class"));
 112                         se2.AddAttribute ("version", se.Attribute ("version"));
 113                         p.FromXml (se2);
 114                 }
 115
 116                 [Test]
 117                 [ExpectedException (typeof (ArgumentException))]
 118                 public void FromXmlWrongVersion ()
 119                 {
 120                         PrincipalPermission p = new PrincipalPermission (PermissionState.None);
 121                         SecurityElement se = p.ToXml ();
 122                         // can't modify - so we create our own
 123                         SecurityElement se2 = new SecurityElement (se.Tag, se.Text);
 124                         se2.AddAttribute ("class", se.Attribute ("class"));
 125                         se2.AddAttribute ("version", "2");
 126                         p.FromXml (se2);
 127                 }
 128
 129                 [Test]
 130                 public void FromXml ()
 131                 {
 132                         PrincipalPermission p = new PrincipalPermission (PermissionState.None);
 133                         SecurityElement se = p.ToXml ();
 134                         AssertNotNull ("ToXml()", se);
 135
 136                         PrincipalPermission p2 = (PrincipalPermission) p.Copy ();
 137                         p2.FromXml (se);
 138                         AssertEquals ("FromXml-Copy", p.ToString (), p2.ToString ());
 139
 140                         string className = (string) se.Attributes ["class"];
 141                         string version = (string) se.Attributes ["version"];
 142
 143                         SecurityElement se2 = new SecurityElement (se.Tag);
 144                         se2.AddAttribute ("class", className);
 145                         se2.AddAttribute ("version", version);
 146                         p2.FromXml (se2);
 147
 148                         SecurityElement sec = new SecurityElement ("Identity");
 149                         sec.AddAttribute ("Authenticated", "true");
 150                         se2.AddChild (sec);
 151                         p2.FromXml (se2);
 152                         Assert ("FromXml-Unrestricted", p2.IsUnrestricted ());
 153                 }
 154
 155                 [Test]
 156                 public void UnionWithNull ()
 157                 {
 158                         PrincipalPermission p1 = new PrincipalPermission ("user", null);
 159                         PrincipalPermission p2 = null;
 160                         PrincipalPermission p3 = (PrincipalPermission) p1.Union (p2);
 161                         AssertEquals ("P1 U null == P1", p1.ToXml ().ToString (), p3.ToXml ().ToString ());
 162                 }
 163
 164                 [Test]
 165                 public void UnionWithUnrestricted ()
 166                 {
 167                         PrincipalPermission p1 = new PrincipalPermission (PermissionState.Unrestricted);
 168                         PrincipalPermission p2 = new PrincipalPermission ("user", "role");
 169                         PrincipalPermission p3 = (PrincipalPermission) p1.Union (p2);
 170                         Assert ("Unrestricted U P2 == Unrestricted", p3.IsUnrestricted ());
 171                         p3 = (PrincipalPermission) p2.Union (p1);
 172                         Assert ("P2 U Unrestricted == Unrestricted", p3.IsUnrestricted ());
 173                 }
 174
 175                 [Test]
 176                 public void Union ()
 177                 {
 178                         PrincipalPermission p1 = new PrincipalPermission ("user A", "role A");
 179                         PrincipalPermission p2 = new PrincipalPermission ("user B", "role B", false);
 180                         PrincipalPermission p3 = (PrincipalPermission) p1.Union (p2);
 181                         Assert ("Union.UserA", p3.ToString ().IndexOf ("user A") >= 0);
 182                         Assert ("Union.UserB", p3.ToString ().IndexOf ("user B") >= 0);
 183                 }
 184
 185                 [Test]
 186                 [ExpectedException (typeof (ArgumentException))]
 187                 public void UnionWithBadPermission ()
 188                 {
 189                         PrincipalPermission p1 = new PrincipalPermission ("user", null);
 190                         EnvironmentPermission ep2 = new EnvironmentPermission (PermissionState.Unrestricted);
 191                         PrincipalPermission p3 = (PrincipalPermission) p1.Union (ep2);
 192                 }
 193
 194                 [Test]
 195                 public void IntersectWithNull ()
 196                 {
 197                         PrincipalPermission p1 = new PrincipalPermission ("user", "role");
 198                         PrincipalPermission p2 = null;
 199                         PrincipalPermission p3 = (PrincipalPermission) p1.Intersect (p2);
 200                         AssertNull ("P1 N null == null", p3);
 201                 }
 202
 203                 [Test]
 204                 public void IntersectWithUnrestricted ()
 205                 {
 206                         PrincipalPermission p1 = new PrincipalPermission (PermissionState.Unrestricted);
 207                         PrincipalPermission p2 = new PrincipalPermission ("user", "role");
 208                         PrincipalPermission p3 = (PrincipalPermission) p1.Intersect (p2);
 209                         Assert ("Unrestricted N P2 == P2", !p3.IsUnrestricted ());
 210                         AssertEquals ("Unrestricted N EP2 == EP2", p2.ToXml ().ToString (), p3.ToXml ().ToString ());
 211                         p3 = (PrincipalPermission) p2.Intersect (p1);
 212                         Assert ("P2 N Unrestricted == P2", !p3.IsUnrestricted ());
 213                         AssertEquals ("P2 N Unrestricted == P2", p2.ToXml ().ToString (), p3.ToXml ().ToString ());
 214                 }
 215
 216                 [Test]
 217                 public void Intersect ()
 218                 {
 219                         // no intersection
 220                         PrincipalPermission p1 = new PrincipalPermission ("user A", "role 1");
 221                         PrincipalPermission p2 = new PrincipalPermission ("user B", "role 2");
 222                         PrincipalPermission p3 = (PrincipalPermission) p1.Intersect (p2);
 223                         AssertNull ("EP1 N EP2 == null", p3);
 224                         // intersection in role
 225                         PrincipalPermission p4 = new PrincipalPermission ("user C", "role 1");
 226                         p3 = (PrincipalPermission) p4.Intersect (p1);
 227                         Assert ("Intersect (!user A)", p3.ToString ().IndexOf ("user A") < 0);
 228                         Assert ("Intersect (!user C)", p3.ToString ().IndexOf ("user C") < 0);
 229                         Assert ("Intersect (role 1)", p3.ToString ().IndexOf ("role 1") >= 0);
 230                         // intersection in role without authentication
 231                         PrincipalPermission p5 = new PrincipalPermission ("user C", "role 1", false);
 232                         p3 = (PrincipalPermission) p5.Intersect (p1);
 233                         AssertNull ("EP5 N EP1 == null", p3);
 234                 }
 235
 236                 [Test]
 237                 public void IntersectNullName ()
 238                 {
 239                         PrincipalPermission p1 = new PrincipalPermission ("user", "role");
 240                         PrincipalPermission p2 = new PrincipalPermission (null, "role");
 241                         PrincipalPermission p3 = (PrincipalPermission) p1.Intersect (p2);
 242                         AssertEquals ("p1 N p2 == p1", p1.ToString (), p3.ToString ());
 243                         p3 = (PrincipalPermission) p2.Intersect (p1);
 244                         AssertEquals ("p2 N p1 == p1", p1.ToString (), p3.ToString ());
 245                 }
 246
 247                 [Test]
 248                 public void IntersectNullRole ()
 249                 {
 250                         PrincipalPermission p1 = new PrincipalPermission ("user", "role");
 251                         PrincipalPermission p2 = new PrincipalPermission ("user", null);
 252                         PrincipalPermission p3 = (PrincipalPermission) p1.Intersect (p2);
 253                         AssertEquals ("p1 N p2 == p1", p1.ToString (), p3.ToString ());
 254                         p3 = (PrincipalPermission) p2.Intersect (p1);
 255                         AssertEquals ("p2 N p1 == p1", p1.ToString (), p3.ToString ());
 256                 }
 257
 258                 [Test]
 259                 [ExpectedException (typeof (ArgumentException))]
 260                 public void IntersectWithBadPermission ()
 261                 {
 262                         PrincipalPermission p1 = new PrincipalPermission ("user", null);
 263                         EnvironmentPermission ep2 = new EnvironmentPermission (PermissionState.Unrestricted);
 264                         PrincipalPermission p3 = (PrincipalPermission) p1.Intersect (ep2);
 265                 }
 266
 267                 [Test]
 268                 public void IsSubsetOfNull ()
 269                 {
 270                         PrincipalPermission p = new PrincipalPermission ("user", null);
 271                         Assert ("User.IsSubsetOf(null)", !p.IsSubsetOf (null));
 272                 }
 273
 274                 [Test]
 275                 public void IsSubsetOfUnrestricted ()
 276                 {
 277                         PrincipalPermission p1 = new PrincipalPermission (PermissionState.Unrestricted);
 278                         PrincipalPermission p2 = new PrincipalPermission ("user", "role", false);
 279                         Assert ("Unrestricted.IsSubsetOf(user)", !p1.IsSubsetOf (p2));
 280                         Assert ("user.IsSubsetOf(Unrestricted)", p2.IsSubsetOf (p1));
 281                 }
 282
 283                 [Test]
 284                 public void IsSubsetOf ()
 285                 {
 286                         PrincipalPermission p1 = new PrincipalPermission ("user A", "role 1");
 287                         PrincipalPermission p2 = new PrincipalPermission (null, "role 1");
 288                         Assert ("UserRole.IsSubsetOf(Role)", p1.IsSubsetOf (p2));
 289                         Assert ("Role.IsSubsetOf(UserRole)", !p2.IsSubsetOf (p1));
 290
 291                         PrincipalPermission p3 = new PrincipalPermission ("user A", "role 1", false);
 292                         Assert ("UserRoleAuth.IsSubsetOf(UserRoleNA)", !p3.IsSubsetOf (p1));
 293                         Assert ("UserRoleNA.IsSubsetOf(UserRoleAuth)", !p1.IsSubsetOf (p3));
 294
 295                         PrincipalPermission p4 = new PrincipalPermission (null, null, true); // unrestricted
 296                         Assert ("unrestricted.IsSubsetOf(UserRole)", !p4.IsSubsetOf (p1));
 297                         Assert ("UserRole.IsSubsetOf(unrestricted)", p1.IsSubsetOf (p4));
 298                 }
 299
 300                 [Test]
 301                 [ExpectedException (typeof (ArgumentException))]
 302                 public void IsSubsetOfBadPermission ()
 303                 {
 304                         PrincipalPermission p1 = new PrincipalPermission ("user", null);
 305                         EnvironmentPermission ep2 = new EnvironmentPermission (PermissionState.Unrestricted);
 306                         Assert ("IsSubsetOf(EnvironmentPermission)", p1.IsSubsetOf (ep2));
 307                 }
 308         }
 309 }