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();
}
