mcs/class/System.ServiceModel/Test/System.ServiceModel.PeerResolvers/CustomPeerResolverServiceTest.cs

   1 //
   2 // CustomPeerResolverServiceTest.cs
   3 //
   4 // Author:
   5 //       Marcos Cobena (marcoscobena@gmail.com)
   6 //
   7 // Copyright 2007 Marcos Cobena (http://www.youcannoteatbits.org/)
   8 //
   9
  10 using System;
  11 using System.Collections.Generic;
  12 using System.ServiceModel;
  13 using System.ServiceModel.Description;
  14 using System.ServiceModel.PeerResolvers;
  15 using System.Text;
  16
  17 using NUnit.Framework;
  18
  19 namespace MonoTests.System.ServiceModel.PeerResolvers
  20 {
  21         [TestFixture]
  22         public class CustomPeerResolverServiceTest
  23         {
  24                 private CustomPeerResolverService cprs;
  25
  26                 [SetUp]
  27                 protected void SetUp ()
  28                 {
  29                         cprs = new CustomPeerResolverService ();
  30                 }
  31
  32                 [Test]
  33                 [Category ("NotWorking")]
  34                 public void CloseTest ()
  35                 {
  36                         cprs.Open ();
  37                         cprs.Close ();
  38                 }
  39
  40                 [Test]
  41                 [ExpectedException (typeof (InvalidOperationException))]
  42                 public void CloseTest1 ()
  43                 {
  44                         cprs.Close ();
  45                 }
  46
  47                 [Test]
  48                 [ExpectedException (typeof (InvalidOperationException))]
  49                 public void GetServiceSettingsTest ()
  50                 {
  51                         ServiceSettingsResponseInfo ssri;
  52
  53                         ssri = cprs.GetServiceSettings ();
  54                 }
  55
  56                 [Test]
  57                 [ExpectedException (typeof (ArgumentException))]
  58                 public void OpenTest1 ()
  59                 {
  60                         cprs.CleanupInterval = TimeSpan.Zero;
  61                         cprs.Open ();
  62                 }
  63
  64                 [Test]
  65                 [ExpectedException (typeof (ArgumentException))]
  66                 public void OpenTest2 ()
  67                 {
  68                         cprs.RefreshInterval = TimeSpan.Zero;
  69                         cprs.Open ();
  70                 }
  71
  72                 [Test]
  73                 [ExpectedException (typeof (ArgumentException))]
  74                 public void OpenTest3 ()
  75                 {
  76                         cprs.CleanupInterval = TimeSpan.Zero;
  77                         cprs.RefreshInterval = TimeSpan.Zero;
  78                         cprs.Open ();
  79                 }
  80
  81                 [Test]
  82                 [ExpectedException (typeof (InvalidOperationException))]
  83                 [Category ("NotWorking")]
  84                 public void OpenTest4 ()
  85                 {
  86                         cprs.Open ();
  87                         try {
  88                                 cprs.Open ();
  89                         } finally {
  90                                 cprs.Close ();
  91                         }
  92                 }
  93
  94                 [Test]
  95                 [ExpectedException (typeof (ArgumentException))]
  96                 public void RefreshTest ()
  97                 {
  98                         cprs.Refresh (null);
  99                 }
 100
 101                 [Test]
 102                 [ExpectedException (typeof (InvalidOperationException))]
 103                 public void RefreshTest1 ()
 104                 {
 105                         cprs.Refresh (new RefreshInfo ());
 106                 }
 107
 108                 //[Test]
 109                 //public void RefreshTest2 ()
 110                 //{
 111                 //      cprs.Open ();
 112                 //      cprs.Refresh(new RefreshInfo ("foo", new Guid ()));
 113                 //}
 114
 115                 [Test]
 116                 [ExpectedException (typeof( ArgumentException))]
 117                 public void RegisterTest ()
 118                 {
 119                         cprs.Register (null);
 120                 }
 121
 122                 [Test]
 123                 [ExpectedException (typeof (InvalidOperationException))]
 124                 public void RegisterTest1 ()
 125                 {
 126                         cprs.Register (new RegisterInfo ());
 127                 }
 128
 129                 //[Test]
 130                 //public void RegisterTest2 ()
 131                 //{
 132                 //      cprs.Open ();
 133                 //      cprs.Register(new RegisterInfo ());
 134                 //}
 135
 136                 [Test]
 137                 [ExpectedException (typeof (ArgumentException))]
 138                 public void ResolveTest ()
 139                 {
 140                         cprs.Resolve (null);
 141                 }
 142
 143                 [Test]
 144                 [ExpectedException (typeof (InvalidOperationException))]
 145                 public void ResolveTest1 ()
 146                 {
 147                         cprs.Resolve (new ResolveInfo ());
 148                 }
 149
 150                 //[Test]
 151                 //public void ResolveTest2 ()
 152                 //{
 153                 //      cprs.Open ();
 154                 //      cprs.Resolve (new ResolveInfo ());
 155                 //}
 156
 157                 [Test]
 158                 [ExpectedException (typeof (ArgumentException))]
 159                 public void UnregisterTest ()
 160                 {
 161                         cprs.Unregister (null);
 162                 }
 163
 164                 [Test]
 165                 [ExpectedException (typeof (InvalidOperationException))]
 166                 public void UnregisterTest1 ()
 167                 {
 168                         cprs.Unregister (new UnregisterInfo ());
 169                 }
 170
 171                 //[Test]
 172                 //public void UnregisterTest2 ()
 173                 //{
 174                 //      cprs.Open ();
 175                 //      cprs.Unregister (new UnregisterInfo ());
 176                 //}
 177
 178                 [Test]
 179                 [ExpectedException (typeof (ArgumentException))]
 180                 public void UpdateTest ()
 181                 {
 182                         cprs.Update (null);
 183                 }
 184
 185                 [Test]
 186                 [ExpectedException (typeof (InvalidOperationException))]
 187                 public void UpdateTest1 ()
 188                 {
 189                         cprs.Update (new UpdateInfo ());
 190                 }
 191
 192                 //[Test]
 193                 //public void UpdateTest2 ()
 194                 //{
 195                 //      cprs.Open ();
 196                 //      cprs.Update (new UpdateInfo ());
 197                 //}
 198
 199                 [Test]
 200                 public void Contract ()
 201                 {
 202                         var cd = ContractDescription.GetContract (typeof (IPeerResolverContract));
 203                         Assert.IsNull (cd.CallbackContractType, "#1");
 204                         Assert.AreEqual (typeof (IPeerResolverContract), cd.ContractType, "#2");
 205                         Assert.AreEqual (SessionMode.Allowed, cd.SessionMode, "#3");
 206                 }
 207         }
 208 }