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