public void AddRoadTrip_WhenAllCondiontsAreFullfield_ShouldNotThrowBusinessException() { //Arrange RoadTrip firstRoadTrip = new RoadTrip(); firstRoadTrip.departureTime = new TimeSpan(4, 10, 0); firstRoadTrip.arrivalTime = new TimeSpan(5, 10, 0); firstRoadTrip.distance = 40; RoadTrip secondRoadTrip = new RoadTrip(); secondRoadTrip.departureTime = new TimeSpan(6, 10, 0); secondRoadTrip.arrivalTime = new TimeSpan(7, 10, 0); secondRoadTrip.distance = 50; List <RoadTrip> roadList = new List <RoadTrip>(); roadList.Add(firstRoadTrip); roadList.Add(secondRoadTrip); SystemUnderTest.AddRoadTrip(firstRoadTrip); SystemUnderTest.AddRoadTrip(secondRoadTrip); RoadTrip thirdRoadTrip = new RoadTrip(); thirdRoadTrip.departureTime = new TimeSpan(10, 20, 0); thirdRoadTrip.arrivalTime = new TimeSpan(11, 20, 0); thirdRoadTrip.distance = 5; //Act AssertionExtensions.ShouldNotThrow <BusinessException>(() => SystemUnderTest.AddRoadTrip(thirdRoadTrip)); }
public void AddRoadTrip_RoadTripOverlapingSchedule_ShouldThrowBusinessException() { //Arrange RoadTrip firstRoadTrip = new RoadTrip(); firstRoadTrip.departureTime = new TimeSpan(4, 10, 0); firstRoadTrip.arrivalTime = new TimeSpan(5, 10, 0); RoadTrip secondRoadTrip = new RoadTrip(); secondRoadTrip.departureTime = new TimeSpan(6, 10, 0); secondRoadTrip.arrivalTime = new TimeSpan(7, 10, 0); List <RoadTrip> roadList = new List <RoadTrip>(); roadList.Add(firstRoadTrip); roadList.Add(secondRoadTrip); SystemUnderTest.schedule = roadList; RoadTrip overlappingRoadTrip = new RoadTrip(); overlappingRoadTrip.departureTime = new TimeSpan(5, 20, 0); overlappingRoadTrip.arrivalTime = new TimeSpan(8, 20, 0); //Act AssertionExtensions.ShouldThrow <BusinessException>(() => SystemUnderTest.AddRoadTrip(overlappingRoadTrip)); }
public void AddRoadTrip_WhenBusMilageExceds_ShouldThrowBusinessException() { //Arrange RoadTrip firstRoadTrip = new RoadTrip(); firstRoadTrip.departureTime = new TimeSpan(4, 10, 0); firstRoadTrip.arrivalTime = new TimeSpan(5, 10, 0); firstRoadTrip.distance = 40; RoadTrip secondRoadTrip = new RoadTrip(); secondRoadTrip.departureTime = new TimeSpan(6, 10, 0); secondRoadTrip.arrivalTime = new TimeSpan(7, 10, 0); secondRoadTrip.distance = 50; List <RoadTrip> roadList = new List <RoadTrip>(); roadList.Add(firstRoadTrip); roadList.Add(secondRoadTrip); SystemUnderTest.AddRoadTrip(firstRoadTrip); SystemUnderTest.AddRoadTrip(secondRoadTrip); RoadTrip excedingDistanceRoadTrip = new RoadTrip(); excedingDistanceRoadTrip.departureTime = new TimeSpan(10, 20, 0); excedingDistanceRoadTrip.arrivalTime = new TimeSpan(11, 20, 0); excedingDistanceRoadTrip.distance = 20; //Act AssertionExtensions.ShouldThrow <BusinessException>(() => SystemUnderTest.AddRoadTrip(excedingDistanceRoadTrip)); }
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 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 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 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 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 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 Must_ReturnAnInstanceThatWrapsTheSuppliedIEnumerable( IEnumerable <object> source) { var snumerable = Smartnumerable.Create(source); AssertionExtensions.SequencesAreEqual(source, snumerable); }
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 AndConstraint <SqlNodeAssertions> MatchAst(ISqlNode expected) { Subject.Should().NotBeNull(); AssertionExtensions.Should(expected).NotBeNull(); AssertMatchAst(Subject, expected, ""); return(new AndConstraint <SqlNodeAssertions>(this)); }
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 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 void When_building_a_dispatcher_with_named_gateway() { _dispatcher = _builder.Build(); //_should_build_a_dispatcher AssertionExtensions.Should((object)_dispatcher).NotBeNull(); }
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(); }
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 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(); }
private void VerifyMessageProcessing(Type handlerType, Type messageType) { _messageBusInitializer.MessageHandlerResolverMock.Received(1).Resolve(handlerType); TestHandlerBase.ArgsReceived.Count.Should().Be(1); var arg = TestHandlerBase.ArgsReceived.First(); AssertionExtensions.ShouldBeEquivalentTo(arg.GetType(), messageType); }
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 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 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); }
public void TestTryGetInternal() { MyValue value = myMetaCache.GetAndChange(); value.Value = "value1"; AssertionExtensions.Should((object)cloneMetaCache.Get()).Be(value); }
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 DtoAdapter_InterfaceWithMethods_Test() { var obj0 = new MyMethodObj() { A = 1 }; AssertionExtensions.Should(() => obj0.DtoAdapter <IMyMethodObj>()).Throw <InvalidOperationException>(); }
public void DtoAdapter_MappingFail_Test() { var obj0 = new MySecondObj() { B = "abc" }; AssertionExtensions.Should(() => obj0.DtoAdapter <IMyObj>()).Throw <InvalidOperationException>(); }
public void DtoAdapter_PrivateInterface_Test() { var obj0 = new MyObj() { A = 1, B = "abc" }; AssertionExtensions.Should(() => obj0.DtoAdapter <IMyPrivateObj>()).Throw <InvalidOperationException>(); }
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 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(); }