public void GetOrCreateRegistrationWhenRegistrationAlreadyExistsTest() { var expectedRegistration = new Registration { ID = 3, ClientId = "client-id", ClientSecret = "client-secret", Instance = "mastodon.instance", MastodonAppRegistrationID = "42" }; _mockData.Setup(d => d.GetAppRegistration("mastodon.instance")).Returns(expectedRegistration); var herdApp = new HerdApp(_mockData.Object, _mockHashTagRelevanceManager.Object, _mockMastodonApiWrapper.Object, _mockLogger.Object); var result = herdApp.GetOrCreateRegistration(new GetOrCreateRegistrationCommand { Instance = "mastodon.instance" }); // Verify the result Assert.True(result?.Success); ExtendedAssert.ObjectsEqual(expectedRegistration, result.Data.Registration); // Make sure the GetAppRegistration was called once and CreateAppRegistration was never called _mockData.Verify(d => d.GetAppRegistration("mastodon.instance"), Times.Once()); _mockData.Verify(d => d.CreateAppRegistration(It.Is <Registration>(r => true)), Times.Never()); }
public void GeoRectangle_Wraparound() { // Verify that we detect coordinate wraparound. ExtendedAssert.Throws <ArgumentException>(() => new GeoRectangle(new GeoCoordinate(45, 5), new GeoCoordinate(60, 0))); ExtendedAssert.Throws <ArgumentException>(() => new GeoRectangle(new GeoCoordinate(45, -10), new GeoCoordinate(0, 0))); }
public void IsSemver() { ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.0.0-alpha-a.b-c-somethinglong+build.1-aef.1-its-okay"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.0.0+0.build.1-rc.10000aaa-kk-0.1"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.0.0-rc.1+build.1"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "2.0.0-rc.1+build.123"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "0.0.4"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.2.3"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "10.20.30"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.2.3-beta"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "10.2.3-DEV-SNAPSHOT"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.2.3-SNAPSHOT-123"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.0.0"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "2.0.0"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.1.7"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "2.0.0+build.1848"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "2.0.1-alpha.1227"); ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.2.3----RC-SNAPSHOT.12.9.1--.12+788"); ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "01.1.1"); ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "1.2"); ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "1.2.3.DEV"); ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "1.2-SNAPSHOT"); ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "1.2.3----RC-SNAPSHOT.12.09.1--..12+788"); ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "1.2-RC-SNAPSHOT"); ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "-1.0.3-gamma+b7718"); }
public void AsymmetricCrypto_EncryptedCredentials() { string privateKey = AsymmetricCrypto.CreatePrivateKey(CryptoAlgorithm.RSA, 1024); string publicKey = AsymmetricCrypto.GetPublicKey(CryptoAlgorithm.RSA, privateKey); Credentials credentials; byte[] encrypted; credentials = new Credentials("realm", "user", "password"); encrypted = AsymmetricCrypto.EncryptCredentials(credentials, "RSA", publicKey); credentials = AsymmetricCrypto.DecryptCredentials(encrypted, "RSA", privateKey); Assert.AreEqual("realm", credentials.Realm); Assert.AreEqual("user", credentials.Account); Assert.AreEqual("password", credentials.Password); // Force a security failure by decrypting with the wrong key ExtendedAssert.Throws <SecurityException>( () => { privateKey = AsymmetricCrypto.CreatePrivateKey(CryptoAlgorithm.RSA, 1024); AsymmetricCrypto.DecryptCredentials(encrypted, "RSA", privateKey); }); // Force a security failure by tampering with the encrypted credentials ExtendedAssert.Throws <SecurityException>( () => { encrypted[4] = (byte)~encrypted[4]; AsymmetricCrypto.DecryptCredentials(encrypted, "RSA", privateKey); }); }
public void CompositeEnumerator_SourceChanged() { // Verify that InvalidOperationExceptions are thrown when the when // performing operations on the enumerator after the source has // signalled that it has been modified. List <int> source = new List <int>(); CompositeEnumerator <int> enumerator; source.Add(0); source.Add(1); source.Add(2); enumerator = new CompositeEnumerator <int>(source.GetEnumerator()); enumerator.OnSourceChanged(); ExtendedAssert.Throws <InvalidOperationException>(() => enumerator.MoveNext()); enumerator = new CompositeEnumerator <int>(source.GetEnumerator()); enumerator.OnSourceChanged(); ExtendedAssert.Throws <InvalidOperationException>(() => { int i = enumerator.Current; }); enumerator = new CompositeEnumerator <int>(source.GetEnumerator()); enumerator.OnSourceChanged(); ExtendedAssert.Throws <InvalidOperationException>(() => { enumerator.Reset(); }); }
public void GeoCoordinate_Valiate() { ExtendedAssert.Throws <ArgumentException>(() => new GeoCoordinate(91.0, 0)); ExtendedAssert.Throws <ArgumentException>(() => new GeoCoordinate(-91.0, 0)); ExtendedAssert.Throws <ArgumentException>(() => new GeoCoordinate(0, 181.0)); ExtendedAssert.Throws <ArgumentException>(() => new GeoCoordinate(0, -181.0)); }
public void Throws_Exception_On_Empty_Or_Null_String() { var myValidator = new Validator(); ExtendedAssert.Throws <InvalidOperationException>(() => myValidator.VerifyNotNullOrEmpty(string.Empty)); ExtendedAssert.Throws <InvalidOperationException>(() => myValidator.VerifyNotNullOrEmpty(null)); }
public void SerializedActionQueue_Limit() { // Verify that the queue throws an [InvalidOperationException] if the number of items in // the queue are exceeded. I'm going to do this by queuing a relatively long-running action // and then quickly submitting four more actions where the last one should exceed the limit // of three actions I'm going to set for the queue. var queue = new SerializedActionQueue(3); var done = false; var task1 = false; try { queue.EnqueueAction(() => { task1 = true; Thread.Sleep(TimeSpan.FromSeconds(1)); done = true; }); Helper.WaitFor(() => task1, TimeSpan.FromSeconds(1)); queue.EnqueueAction(() => Thread.Sleep(0)); queue.EnqueueAction(() => Thread.Sleep(0)); queue.EnqueueAction(() => Thread.Sleep(0)); ExtendedAssert.Throws <InvalidOperationException>(() => queue.EnqueueAction(() => Thread.Sleep(0))); Helper.WaitFor(() => done, TimeSpan.FromSeconds(5)); } finally { queue.Clear(); } }
public void Throws_An_Exception_When_Any_Argument_Is_Null() { string one = "asdf"; string two = "sadf"; string three = null; ExtendedAssert.Throws <ArgumentNullException>(() => new Validator().VerifyParamsNonNull(one, two, three)); }
public void Dispose_Of_The_Http_Client() { var target = new GithubInquisitor(); target.Dispose(); ExtendedAssert.Throws(() => target.Client.CancelPendingRequests()); }
public void AsyncManualResetEvent_Error() { AsyncManualResetEvent manualEvent; // Verify that we get and [ObjectDisposedException] for [Set()] and [Reset()] // a disposed event. manualEvent = new AsyncManualResetEvent(); manualEvent.Dispose(); ExtendedAssert.Throws <ObjectDisposedException>(() => manualEvent.Set()); ExtendedAssert.Throws <ObjectDisposedException>(() => manualEvent.Reset()); Task.Run(() => ExtendedAssert.ThrowsAsync <ObjectDisposedException>(async() => await manualEvent.WaitAsync())).Wait(); // Verify that disposing an event causes any waiting tasks // to unblock with an [ObjectDisposedException]. manualEvent = new AsyncManualResetEvent(); var taskInfo = new TaskStateCollection(); var badException = false; for (int i = 0; i < taskInfo.Count; i++) { new Task( async state => { int taskIndex = (int)state; taskInfo[taskIndex].IsRunning = true; try { await manualEvent.WaitAsync(); } catch (ObjectDisposedException) { taskInfo[taskIndex].IsFaulted = true; } catch { badException = true; taskInfo[taskIndex].IsFaulted = true; } taskInfo[taskIndex].IsComplete = true; }, i).Start(); } Helper.WaitFor(() => taskInfo.AllRunning, defaultTimeout); Assert.IsFalse(taskInfo.AnyComplete); manualEvent.Dispose(); Helper.WaitFor(() => taskInfo.AllFaulted, defaultTimeout); Assert.IsFalse(badException); }
public void DynDnsClientSettings_LoadCluster() { var cfg = @" §ion DynDnsClient Enabled = true NetworkBinding = ANY Mode = CLUSTER SharedKey = aes:ac2qGMV/VZXXdwdjFvaOBpLjOJgOuG6SbM86w3xk0NM=:B4s0wIHjn+PdRHsIcBgJPQ== // Domain = ANY // NameServer[0] = BkInterval = 3s DomainRefreshInterval = 4m UdpRegisterInterval = 5m §ion Cluster ClusterBaseEP = abstract://LillTek/DataCenter/DynDNS Mode = Normal MasterBroadcastInterval = 1s SlaveUpdateInterval = 1s ElectionInterval = 3s MissingMasterCount = 3 MissingSlaveCount = 3 MasterBkInterval = 1s SlaveBkInterval = 1s BkInterval = 1s &endsection &endsection "; try { DynDnsClientSettings settings; Config.SetConfig(cfg.Replace('&', '#')); settings = new DynDnsClientSettings("DynDnsClient"); Assert.IsTrue(settings.Enabled); Assert.IsTrue(settings.NetworkBinding.IsAny); Assert.AreEqual(DynDnsMode.Cluster, settings.Mode); Assert.AreNotEqual(new DynDnsClientSettings().SharedKey.ToString(), settings.SharedKey.ToString()); Assert.IsTrue(settings.Domain.IsAny); ExtendedAssert.IsEmpty(settings.NameServers); Assert.AreEqual(TimeSpan.FromSeconds(3), settings.BkInterval); Assert.AreEqual(TimeSpan.FromMinutes(4), settings.DomainRefreshInterval); Assert.AreEqual(TimeSpan.FromMinutes(5), settings.UdpRegisterInterval); Assert.IsNotNull(settings.Cluster); } finally { Config.SetConfig(null); } }
public void ReadOnlyDictionary_TryModify() { var dictionary = new Dictionary <string, string>(); var readOnly = new ReadOnlyDictionary <string, string>(dictionary); ExtendedAssert.Throws <NotSupportedException>(() => readOnly.Clear()); ExtendedAssert.Throws <NotSupportedException>(() => readOnly.Add("hello", "world")); ExtendedAssert.Throws <NotSupportedException>(() => readOnly["test"] = "fail"); ExtendedAssert.Throws <NotSupportedException>(() => readOnly.Remove("hello")); ExtendedAssert.Throws <NotSupportedException>(() => readOnly.Remove(new KeyValuePair <string, string>("hello", "world"))); }
public void ChannelVariableCollection_Exceptions() { var variables = new ChannelVariableCollection(); ExtendedAssert.Throws <ArgumentNullException>(() => variables.Add(null, "value")); ExtendedAssert.Throws <ArgumentNullException>(() => variables.Add("name", null)); ExtendedAssert.Throws <ArgumentException>(() => variables.Add("", "value")); ExtendedAssert.Throws <ArgumentException>(() => variables.Add("=", "value")); ExtendedAssert.Throws <ArgumentException>(() => variables.Add(",", "value")); ExtendedAssert.Throws <ArgumentException>(() => variables.Add("name", "^")); }
public void Exception_CanBeSerialized() { var expectations = Expectations.GetInnerExceptionsWithNull(); foreach (var e in expectations) { var error = CreateCompositionError(e); var result = SerializationTestServices.RoundTrip(error); ExtendedAssert.IsInstanceOfSameType(error.Exception, result.Exception); } }
public void SwitchEventCodeSet_ReadOnly() { var readOnly = new SwitchEventCodeSet(SwitchEventCode.Heartbeat); readOnly.IsReadOnly = true; Assert.IsTrue(readOnly.IsReadOnly); Assert.IsTrue(readOnly.Contains(SwitchEventCode.Heartbeat)); ExtendedAssert.Throws <InvalidOperationException>(() => readOnly.IsReadOnly = false); ExtendedAssert.Throws <InvalidOperationException>(() => readOnly.Add(SwitchEventCode.Dtmf)); ExtendedAssert.Throws <InvalidOperationException>(() => readOnly.Remove(SwitchEventCode.Dtmf)); ExtendedAssert.Throws <InvalidOperationException>(() => readOnly.Clear()); }
public void InnerException_CanBeSerialized() { var expectations = Expectations.GetInnerExceptions(); foreach (var e in expectations) { var exception = CreateComposablePartException(e); var result = SerializationTestServices.RoundTrip(exception); ExtendedAssert.IsInstanceOfSameType(exception.InnerException, result.InnerException); } }
public void InnerException_CanBeSerialized() { var expectations = Expectations.GetInnerExceptionsWithNull(); foreach (var e in expectations) { var exception = CreateCardinalityMismatchException(e); var result = SerializationTestServices.RoundTrip(exception); ExtendedAssert.IsInstanceOfSameType(exception.InnerException, result.InnerException); } }
public void ArgCollection_ReadOnly() { ArgCollection ps = new ArgCollection(); ps["hello"] = "world!"; Assert.IsFalse(ps.IsReadOnly); Assert.AreEqual("world!", ps["hello"]); ps.IsReadOnly = true; Assert.IsTrue(ps.IsReadOnly); Assert.AreEqual("world!", ps["hello"]); ExtendedAssert.Throws <InvalidOperationException>(() => ps.IsReadOnly = false); ExtendedAssert.Throws <NotSupportedException>(() => ps["foo"] = "bar"); }
public void DynDnsClientSettings_Defaults() { DynDnsClientSettings def = new DynDnsClientSettings(); Assert.IsTrue(def.Enabled); Assert.IsTrue(def.NetworkBinding.IsAny); Assert.AreEqual(DynDnsMode.Cluster, def.Mode); Assert.IsNotNull(def.SharedKey); Assert.IsTrue(def.Domain.IsAny); ExtendedAssert.IsEmpty(def.NameServers); ExtendedAssert.IsEmpty(def.Hosts); Assert.AreEqual(TimeSpan.FromSeconds(1), def.BkInterval); Assert.AreEqual(TimeSpan.FromMinutes(15), def.DomainRefreshInterval); Assert.AreEqual(TimeSpan.FromMinutes(1), def.UdpRegisterInterval); Assert.IsNull(def.Cluster); }
public void GeoCompositeRegion_VerifyNotComposible() { // Verify that we get an exception when trying to compose a composite region // as a subtractive region. ExtendedAssert.Throws <ArgumentException>( () => { new GeoCompositeRegion( new GeoRegion[] { new GeoRectangle(30, 0, 0, 30) }, new GeoRegion[] { new GeoCompositeRegion(new GeoRegion[0]) }); }); }
public void DynDnsClientSettings_LoadUdpDomain() { var cfg = @" §ion DynDnsClient Enabled = true NetworkBinding = ANY Mode = UDP SharedKey = aes:ac2qGMV/VZXXdwdjFvaOBpLjOJgOuG6SbM86w3xk0NM=:B4s0wIHjn+PdRHsIcBgJPQ== Domain = lilltek.net:DYNAMIC-DNS // NameServer[0] = BkInterval = 3s DomainRefreshInterval = 4m UdpRegisterInterval = 5m &endsection "; try { DynDnsClientSettings settings; Config.SetConfig(cfg.Replace('&', '#')); settings = new DynDnsClientSettings("DynDnsClient"); Assert.IsTrue(settings.Enabled); Assert.IsTrue(settings.NetworkBinding.IsAny); Assert.AreEqual(DynDnsMode.Udp, settings.Mode); Assert.AreNotEqual(new DynDnsClientSettings().SharedKey.ToString(), settings.SharedKey.ToString()); Assert.AreEqual(new NetworkBinding("lilltek.net", NetworkPort.DynamicDns), settings.Domain); ExtendedAssert.IsEmpty(settings.NameServers); Assert.AreEqual(TimeSpan.FromSeconds(3), settings.BkInterval); Assert.AreEqual(TimeSpan.FromMinutes(4), settings.DomainRefreshInterval); Assert.AreEqual(TimeSpan.FromMinutes(5), settings.UdpRegisterInterval); Assert.IsNull(settings.Cluster); } finally { Config.SetConfig(null); } }
public void KeyChain_Basic() { string privateKey1 = AsymmetricCrypto.CreatePrivateKey(CryptoAlgorithm.RSA, 1024); string publicKey1 = AsymmetricCrypto.GetPublicKey(CryptoAlgorithm.RSA, privateKey1); string privateKey2 = AsymmetricCrypto.CreatePrivateKey(CryptoAlgorithm.RSA, 1024); string publicKey2 = AsymmetricCrypto.GetPublicKey(CryptoAlgorithm.RSA, privateKey2); KeyChain keyChain = new KeyChain(); ExtendedAssert.Throws <CryptographicException>( () => { keyChain.GetPrivateKey(publicKey1); }); keyChain.Add(privateKey1); keyChain.Add(privateKey2); Assert.AreEqual(privateKey1, keyChain.GetPrivateKey(publicKey1)); Assert.AreEqual(privateKey2, keyChain.GetPrivateKey(publicKey2)); }
public void Bits_ShiftLeft() { var b = new Bits("001100111001111001111100111111001111111"); Assert.AreEqual("001100111001111001111100111111001111111", (string)(b << 0)); Assert.AreEqual("011001110011110011111001111110011111110", (string)(b << 1)); Assert.AreEqual("110011100111100111110011111100111111100", (string)(b << 2)); Assert.AreEqual("100111001111001111100111111001111111000", (string)(b << 3)); Assert.AreEqual("001110011110011111001111110011111110000", (string)(b << 4)); Assert.AreEqual("011100111100111110011111100111111100000", (string)(b << 5)); var s = b.ToString(); for (int i = 0; i < 100; i++) { Assert.AreEqual(s, (string)(b << i)); s = s.Substring(1) + "0"; } ExtendedAssert.Throws <ArgumentException>(() => { var output = b << -1; }); }
public void Bits_ShiftRight() { var b = new Bits("001100111001111001111100111111001111111"); Assert.AreEqual("001100111001111001111100111111001111111", (string)(b >> 0)); Assert.AreEqual("000110011100111100111110011111100111111", (string)(b >> 1)); Assert.AreEqual("000011001110011110011111001111110011111", (string)(b >> 2)); Assert.AreEqual("000001100111001111001111100111111001111", (string)(b >> 3)); Assert.AreEqual("000000110011100111100111110011111100111", (string)(b >> 4)); Assert.AreEqual("000000011001110011110011111001111110011", (string)(b >> 5)); var s = b.ToString(); for (int i = 0; i < 100; i++) { Assert.AreEqual(s, (string)(b >> i)); s = "0" + s.Substring(0, s.Length - 1); } ExtendedAssert.Throws <ArgumentException>(() => { var output = b >> -1; }); }
public void GetRegistrationTest() { var expectedRegistration = new Registration { ID = 3, ClientId = "client-id", ClientSecret = "client-secret", Instance = "mastodon.instance", MastodonAppRegistrationID = "42" }; _mockData.Setup(d => d.GetAppRegistration(3)).Returns(expectedRegistration); var herdApp = new HerdApp(_mockData.Object, _mockHashTagRelevanceManager.Object, _mockMastodonApiWrapper.Object, _mockLogger.Object); var result = herdApp.GetRegistration(new GetRegistrationCommand { ID = 3 }); Assert.True(result?.Success); ExtendedAssert.ObjectsEqual(expectedRegistration, result.Data.Registration); _mockData.Verify(d => d.GetAppRegistration(3), Times.Once()); }
public void GetOrCreateRegistrationWhenRegistrationDoesNotAlreadyExistTest() { _mockData.Setup(d => d.GetAppRegistration("mastodon.instance")).Returns(null as Registration); _mockMastodonApiWrapper.Setup(a => a.RegisterApp()).Returns(Task.FromResult(new Registration { ClientId = "client-id", ClientSecret = "client-secret", Instance = "mastodon.instance", MastodonAppRegistrationID = "42", ID = -1 })); _mockData.Setup(d => d.CreateAppRegistration(It.Is <Registration>(r => r.Instance == "mastodon.instance"))) .Returns <Registration>(registrationToCreate => registrationToCreate.With(r => r.ID = 3)); var herdApp = new HerdApp(_mockData.Object, _mockHashTagRelevanceManager.Object, _mockMastodonApiWrapper.Object, _mockLogger.Object); var result = herdApp.GetOrCreateRegistration(new GetOrCreateRegistrationCommand { Instance = "mastodon.instance" }); // Verify the result var expectedRegistration = new Registration { ID = 3, ClientId = "client-id", ClientSecret = "client-secret", Instance = "mastodon.instance", MastodonAppRegistrationID = "42" }; Assert.True(result?.Success); ExtendedAssert.ObjectsEqual(expectedRegistration, result.Data.Registration); // Make sure the GetAppRegistration and CreateAppRegistration were each called exactly once _mockData.Verify(d => d.GetAppRegistration("mastodon.instance"), Times.Once()); _mockMastodonApiWrapper.Verify(a => a.RegisterApp(), Times.Once()); _mockData.Verify(d => d.CreateAppRegistration(It.Is <Registration>(r => r.Instance == "mastodon.instance")), Times.Once()); }
public void SecureTicket_Tamper() { DateTime now = DateTime.UtcNow; SymmetricKey key = new SymmetricKey("aes:Cz1uS3EYB5aLDgXdKKmzGPnMU3/QwK1i+8nY3KuUaCw=:Toel2ZQR6TBtOvq+zatyoA=="); SecureTicket ticket; byte[] encrypted; ticket = new SecureTicket("my-resource", TimeSpan.FromSeconds(10)); ticket.Set("arg0", "myarg-0"); ticket.Set("arg1", "myarg-1"); ticket["arg2"] = "myarg-2"; encrypted = ticket.ToArray(key); encrypted[0] = (byte)~encrypted[0]; ExtendedAssert.Throws <CryptographicException>( () => { ticket = SecureTicket.Parse(key, encrypted); Assert.Fail("Expected a CryptographicException"); }); }
public void ValidCommand_DoNotThrowsException() { var stubCommand = GetStubValidCommand(); ExtendedAssert.NotThrowsAnyExceptions(() => addEngineCommandValidator.Validate(stubCommand)); }
public void Does_Not_Throw_On_Valid_Argument() { var myValidator = new Validator(); ExtendedAssert.DoesNotThrow(() => myValidator.VerifyNotNullOrEmpty("a")); }