public void When_building_a_dispatcher_with_named_gateway() { _dispatcher = _builder.Build(); //_should_build_a_dispatcher AssertionExtensions.Should((object)_dispatcher).NotBeNull(); }
public void When_Reading_A_Message_From_The_Inbox_And_ContextKey_IsNull() { var exception = Catch.Exception(() => _storedCommand = _pgSqlInbox.Get <MyCommand>(_raisedCommand.Id, null)); //should_not_read_message AssertionExtensions.Should((object)exception).BeOfType <RequestNotFoundException <MyCommand> >(); }
public static void JsonsBeEquivalent(string actual, string expected) { JToken jsonActual = JToken.Parse(actual); JToken jsonExpected = JToken.Parse(expected); List <string> actualJsonChildren = GetChildrenKeys(jsonActual); List <string> expectedJsonChildren = GetChildrenKeys(jsonExpected); if (actualJsonChildren.Count != expectedJsonChildren.Count) { string actualIsMissing = string.Join(",", GetListDifference(expectedJsonChildren, actualJsonChildren)); string expectedIsMissing = string.Join(",", GetListDifference(actualJsonChildren, expectedJsonChildren)); Assert.Fail("children mismatch: actual JSON has {0} children, expected JSON has {1} children" + "\n actual is missing {2}," + "\n expected is missing {3},", actualJsonChildren.Count, expectedJsonChildren.Count, actualIsMissing, expectedIsMissing); } /* * var newActual = new JArray(actual.Children().OrderBy(c => c.ToString())); * var newExpected = new JArray(expected.Children().OrderBy(c => c.ToString())); * AssertionExtensions.Should(newActual).BeEquivalentTo(newExpected); */ AssertionExtensions.Should(jsonActual).BeEquivalentTo(jsonExpected); }
public async Task When_There_Is_No_Message_In_The_Sql_Inbox_And_I_Get_Async() { Guid commandId = Guid.NewGuid(); var exception = await Catch.ExceptionAsync(() => _sqlSqlInbox.GetAsync <MyCommand>(commandId, "some-key")); AssertionExtensions.Should((object)exception).BeOfType <RequestNotFoundException <MyCommand> >(); }
public void ConcatenatedIteratedTest() { Integer[] array1 = { MakeIntegerStackItem(1), MakeIntegerStackItem(7), MakeIntegerStackItem(23) }; Integer[] array2 = { MakeIntegerStackItem(8), MakeIntegerStackItem(47) }; ArrayWrapper it1 = new ArrayWrapper(array1); ArrayWrapper it2 = new ArrayWrapper(array2); ConcatenatedIterator uut = new ConcatenatedIterator(it1, it2); AssertionExtensions.Should((bool)uut.Next()).Be(true); uut.Key().Should().Be(MakeIntegerStackItem(0)); uut.Value().Should().Be(array1[0]); AssertionExtensions.Should((bool)uut.Next()).Be(true); uut.Key().Should().Be(MakeIntegerStackItem(1)); uut.Value().Should().Be(array1[1]); AssertionExtensions.Should((bool)uut.Next()).Be(true); uut.Key().Should().Be(MakeIntegerStackItem(2)); uut.Value().Should().Be(array1[2]); AssertionExtensions.Should((bool)uut.Next()).Be(true); uut.Key().Should().Be(MakeIntegerStackItem(0)); uut.Value().Should().Be(array2[0]); AssertionExtensions.Should((bool)uut.Next()).Be(true); uut.Key().Should().Be(MakeIntegerStackItem(1)); uut.Value().Should().Be(array2[1]); AssertionExtensions.Should((bool)uut.Next()).Be(false); }
public void ProvideWithReferences() { const string FileName = "filename.txt"; var digestAlgorithm = MessageDigestAlgorithm.SHA256; var manifestType = new ASiCManifestType { DataObjectReference = new[] { new DataObjectReferenceType { Rootfile = false, MimeType = "text/plain", URI = FileName, DigestMethod = new DigestMethodType { Algorithm = digestAlgorithm.Uri.ToString() }, DigestValue = new byte[] { 0, 1, 0, 1 } } } }; var cadesManifest = new CadesManifest(manifestType); AssertionExtensions.Should(cadesManifest).NotBeNull(); var digests = cadesManifest.Digests; digests.Should().NotBeNull(); AssertionExtensions.Should(digests.Count).Be(1); AssertionExtensions.Should(Enumerable.First(digests).Value.MessageDigestAlgorithm).BeEquivalentTo(digestAlgorithm); AssertionExtensions.Should(cadesManifest.SignatureFileRef).BeNull(); }
public void ReadAsicEWithoutManifestAndSignature() { using (var zipOutStream = new MemoryStream()) { using (var createdArchive = new ZipArchive(zipOutStream, ZipArchiveMode.Create)) { var newEntry = createdArchive.CreateEntry(AsiceConstants.FileNameMimeType); using (var entryStream = newEntry.Open()) { entryStream.Write(Encoding.UTF8.GetBytes((string)AsiceConstants.ContentTypeASiCe)); } } using (var zipInStream = new MemoryStream(zipOutStream.ToArray())) { using (var readArchive = new ZipArchive(zipInStream, ZipArchiveMode.Read)) { var asiceArchive = AsiceReadModel.Create(readArchive); AssertionExtensions.Should((object)asiceArchive).NotBeNull(); Enumerable.Count(asiceArchive.Entries).Should().Be(0); AssertionExtensions.Should((object)asiceArchive.CadesManifest).BeNull(); } } } }
public async void When_There_Is_No_Message_In_The_Sql_Inbox() { var exception = await Catch.ExceptionAsync(() => _dynamoDbInbox.GetAsync <MyCommand>(Guid.NewGuid(), "some key")); AssertionExtensions.Should((object)exception).BeOfType <RequestNotFoundException <MyCommand> >(); }
public AndConstraint <SqlNodeAssertions> MatchAst(ISqlNode expected) { Subject.Should().NotBeNull(); AssertionExtensions.Should(expected).NotBeNull(); AssertMatchAst(Subject, expected, ""); return(new AndConstraint <SqlNodeAssertions>(this)); }
public void When_There_Is_No_Message_In_The_Sql_Inbox_And_Call_Get() { Guid commandId = Guid.NewGuid(); var exception = Catch.Exception(() => _storedCommand = _sqlInbox.Get <MyCommand>(commandId, _contextKey)); AssertionExtensions.Should((object)exception).BeOfType <RequestNotFoundException <MyCommand> >(); }
public void TestGetValues() { var values = od.Values; AssertionExtensions.Should((bool)values.Contains(1)).BeTrue(); AssertionExtensions.Should((int)values.Count).Be(3); }
public void TestGetKeys() { var keys = od.Keys; AssertionExtensions.Should((bool)keys.Contains("a")).BeTrue(); AssertionExtensions.Should((int)keys.Count).Be(3); }
public void CreateCadesManifest() { var cadesManifestCreator = CadesManifestCreator.CreateWithoutSignatureFile(); var digestAlgorithm = MessageDigestAlgorithm.SHA256; var fileEntry = new AsicePackageEntry("my.pdf", MimeType.ForString("application/pdf"), digestAlgorithm); fileEntry.Digest = new DigestContainer(new byte[] { 0, 0, 1 }, digestAlgorithm); var entries = new[] { fileEntry }; var manifest = cadesManifestCreator.CreateManifest(entries); AssertionExtensions.Should(manifest).NotBeNull() .And .BeOfType <ManifestContainer>(); manifest.Data.Should().NotBeNull(); AssertionExtensions.Should(manifest.FileName).Be(AsiceConstants.CadesManifestFilename); var xmlManifest = DeserializeManifest(Enumerable.ToArray <byte>(manifest.Data)); xmlManifest.Should().NotBeNull(); xmlManifest.SigReference.Should().BeNull(); xmlManifest.DataObjectReference.Should().HaveCount(1); var dataObjectRef = xmlManifest.DataObjectReference[0]; dataObjectRef.Should().NotBeNull(); dataObjectRef.MimeType.Should().Be(fileEntry.Type.ToString()); dataObjectRef.DigestValue.Should().Equal(fileEntry.Digest.GetDigest()); dataObjectRef.URI.Should().Be(fileEntry.FileName); }
public void Should_allow_dates_within_the_given_interval() { var sut = new GetOverviewApplicationResult("hello", DateTime.Today.AddDays(-30), 31); sut.AddValue(DateTime.Today, 10); AssertionExtensions.Should((int)sut.Values[sut.Values.Length - 1]).Be(10); }
private static bool MatchParameter <T>( T parameter, T expectedParameter, Func <EquivalencyAssertionOptions <T>, EquivalencyAssertionOptions <T> > config) { AssertionExtensions.Should((object)parameter).BeEquivalentTo <T>(expectedParameter, config, ""); return(true); }
public void TestAddInternal() { cloneCache.Add(new MyKey("key1"), new MyValue("value1")); AssertionExtensions.Should((object)cloneCache[new MyKey("key1")]).Be(new MyValue("value1")); cloneCache.Commit(); myDataCache[new MyKey("key1")].Should().Be(new MyValue("value1")); }
public void TestTryGetInternal() { MyValue value = myMetaCache.GetAndChange(); value.Value = "value1"; AssertionExtensions.Should((object)cloneMetaCache.Get()).Be(value); }
public void VerifyNothing() { var digestVerifier = DigestVerifier.Create(ImmutableDictionary <string, DeclaredDigestFile> .Empty); var verification = digestVerifier.Verification(); AssertionExtensions.Should(verification).NotBeNull(); AssertionExtensions.Should(verification.AllValid).BeTrue(); }
public static void AssertRecordsAreTheSame(List <IRecord> actual, List <IRecord> expected) { actual.Should().HaveSameCount(expected); foreach (var aRecord in actual) { AssertionExtensions.Should((bool)AssertContains(expected, aRecord)).BeTrue(); } }
public void When_The_Message_Is_Already_In_The_Inbox() { _exception = Catch.Exception(() => _sqlInbox.Add(_raisedCommand, _contextKey)); //_should_succeed_even_if_the_message_is_a_duplicate _exception.Should().BeNull(); AssertionExtensions.Should((bool)_sqlInbox.Exists <MyCommand>(_raisedCommand.Id, _contextKey)).BeTrue(); }
public async Task WhenGetting_Missing_Client_ThenReturnNull() { var ctx = new TestContext(); var underTest = ctx.GetItemToTest(); var res = await underTest.GetClient(int.MaxValue); AssertionExtensions.Should(res).BeNull(); }
public void VerifySignature() { var signature = TestdataLoader.ReadFromResource("signature.p7s"); var signedData = TestdataLoader.ReadFromResource("signedData.xml"); var signatureVerifier = new SignatureVerifier(); var certificate = signatureVerifier.Validate(signedData, signature); AssertionExtensions.Should((object)certificate).NotBeNull(); }
public void TestDeleteInternal() { myDataCache.Add(new MyKey("key1"), new MyValue("value1")); cloneCache.Delete(new MyKey("key1")); // trackable.State = TrackState.Deleted cloneCache.Commit(); AssertionExtensions.Should((object)cloneCache.TryGet(new MyKey("key1"))).BeNull(); myDataCache.TryGet(new MyKey("key1")).Should().BeNull(); }
public void Insert_Normal_RowWithVersionIsInserted( ) { using var connection = new MemoryDbConnection( ); connection.Execute(_SqlInsertTable, new { Description = "Dummy", CreatedDate = DateTime.Now }); var todo = connection.QuerySingle(_SqlSelectTable); var version = VersionAsLong(todo.Version); AssertionExtensions.Should(version).Be(0x7d1); }
public void When_The_Message_Is_Already_In_The_Inbox_Different_Context() { _sqlInbox.Add(_raisedCommand, "some other key"); var storedCommand = _sqlInbox.Get <MyCommand>(_raisedCommand.Id, "some other key"); //_should_read_the_command_from_the__dynamo_db_inbox AssertionExtensions.Should((object)storedCommand).NotBeNull(); }
public void VerifyNoneChecked() { var digestVerifier = CreateDigestVerifierForTest(); Func <DigestVerificationResult> action = () => digestVerifier.Verification(); AssertionExtensions.Should(action.Should().Throw <DigestVerificationException>().And.Message) .Be("Total number of files processed by the verifier was 0, but 2 files was declared"); }
public void map_field_value_to_column_of_type_object() { var post = MapWithReader(data => { data.Add("Dyno", 25); }); AssertionExtensions.Should((object)post.Dyno).Be(25); }
public void DtoAdapter_InterfaceWithMethods_Test() { var obj0 = new MyMethodObj() { A = 1 }; AssertionExtensions.Should(() => obj0.DtoAdapter <IMyMethodObj>()).Throw <InvalidOperationException>(); }
public void DtoAdapter_PrivateInterface_Test() { var obj0 = new MyObj() { A = 1, B = "abc" }; AssertionExtensions.Should(() => obj0.DtoAdapter <IMyPrivateObj>()).Throw <InvalidOperationException>(); }
public void DtoAdapter_MappingFail_Test() { var obj0 = new MySecondObj() { B = "abc" }; AssertionExtensions.Should(() => obj0.DtoAdapter <IMyObj>()).Throw <InvalidOperationException>(); }