protected override async Task When()
{
SystemUnderTest.AddMessagePublisher <SimpleMessage>(_publisher, string.Empty);
await SystemUnderTest.PublishAsync(new SimpleMessage());
}
protected override Task When()
{
SystemUnderTest.AddMessagePublisher <GenericMessage>(Substitute.For <IMessagePublisher>(), string.Empty);
return(Task.CompletedTask);
}
protected override void WhenAction()
{
SystemUnderTest.AddSerializer <CustomMessage>();
}
protected override void When()
{
SystemUnderTest.WithSnsMessagePublisher <Message>();
}
public void CanBuildDataReturnsFalseForNonTextFormats()
{
Assert.IsFalse(
SystemUnderTest.CanBuildData(uint.MaxValue));
}
public void CallingStopTwiceDoesNotStopListeningTwice()
{
SystemUnderTest.Stop();
_subscriber1.Received(1).StopListening();
}
public WhenStatusRequestIsMade(WebAppFixture app)
{
_system = app.SystemUnderTest;
}
protected override async Task WhenAsync()
{
await SystemUnderTest.PublishAsync(_message, _metadata);
}
protected override void When()
{
SystemUnderTest.AddMessagePublisher <GenericMessage>(_publisher);
SystemUnderTest.Publish(new GenericMessage());
}
protected override async Task When()
{
await SystemUnderTest.PublishAsync(new GenericMessage());
}
protected override void Act()
{
var authorizationFilters = SystemUnderTest.GetAuthorizationFilters(
new[] { Supplied <Claim>() },
Supplied <EdFiAuthorizationContext>());
}
public void ExceptionThrownIfFormatNotSupported()
{
Assert.Throws <MessageFormatNotSupportedException>(() => SystemUnderTest.DeserializeMessage(string.Empty));
}
protected override void When()
{
SystemUnderTest.Publish(_message);
}
public async Task CanReadDescription()
{
Assert.IsNotNull(await SystemUnderTest.GetDescriptionAsync(Substitute.For <IClipboardDataPackage>()));
}
protected override void When()
{
SystemUnderTest.PublishAsync(_message)
.GetAwaiter().GetResult();
}
protected override Task When()
{
SystemUnderTest.WithSnsMessagePublisher <Message>();
return(Task.CompletedTask);
}
public async Task CanFetchPersistedPackages()
{
IncludeFakeFor <IClipboardDataFactory>();
ExcludeFakeFor <IClipboardDataPackageFactory>();
ExcludeFakeFor <IFileManager>();
var clipboardFormat1337 = CreateClipboardFormatFromNumber(1337u);
var clipboardFormat1338 = CreateClipboardFormatFromNumber(1338u);
Container.Resolve <IClipboardDataFactory>()
.With(
x => {
x.CanBuildData(Arg.Any <IClipboardFormat>())
.Returns(true);
x.BuildData(
Arg.Any <IClipboardFormat>(),
Arg.Any <byte[]>())
.Returns(
r => {
var resultingData = Substitute.For <IClipboardData>();
resultingData
.RawData
.Returns(
r.Arg <byte[]>());
resultingData
.RawFormat
.Returns(
r.Arg <IClipboardFormat>());
return(resultingData);
});
});
var fakeData1 = Substitute.For <IClipboardData>()
.With(
x => {
x.RawFormat.Returns(clipboardFormat1337);
x.RawData.Returns(
new byte[]
{
1,
2
});
});
var fakeData2 = Substitute.For <IClipboardData>()
.With(
x => {
x.RawFormat.Returns(clipboardFormat1338);
x.RawData.Returns(
new byte[]
{
3,
4
});
});
var fakePackage1 = Substitute.For <IClipboardDataPackage>();
fakePackage1
.Contents
.Returns(
new List <IClipboardData>(
new[]
{
fakeData1,
fakeData2
}));
var fakePackage2 = Substitute.For <IClipboardDataPackage>();
fakePackage2
.Contents
.Returns(
new List <IClipboardData>(
new[]
{
fakeData2,
fakeData1
}));
await SystemUnderTest.PersistClipboardPackageAsync(fakePackage1);
await SystemUnderTest.PersistClipboardPackageAsync(fakePackage2);
var persistedPackages = await SystemUnderTest.GetPersistedPackagesAsync();
var persistedPackagesArray = persistedPackages.ToArray();
Assert.AreEqual(2, persistedPackagesArray.Length);
var persistedPackage1 = persistedPackagesArray[0];
var persistedPackage2 = persistedPackagesArray[1];
Assert.AreEqual(1, persistedPackage1.Id);
Assert.AreEqual(2, persistedPackage2.Id);
Assert.AreEqual(
1,
persistedPackage1
.Contents[0]
.RawData[0]);
Assert.AreEqual(
2,
persistedPackage1
.Contents[0]
.RawData[1]);
Assert.AreEqual(
3,
persistedPackage1
.Contents[1]
.RawData[0]);
Assert.AreEqual(
4,
persistedPackage1
.Contents[1]
.RawData[1]);
Assert.AreEqual(
3,
persistedPackage2
.Contents[0]
.RawData[0]);
Assert.AreEqual(
4,
persistedPackage2
.Contents[0]
.RawData[1]);
Assert.AreEqual(
1,
persistedPackage2
.Contents[1]
.RawData[0]);
Assert.AreEqual(
2,
persistedPackage2
.Contents[1]
.RawData[1]);
}
public void CanBuildDataReturnsTrueForTextFormats()
{
Assert.IsTrue(
SystemUnderTest.CanBuildData(
ClipboardNativeApi.CF_TEXT));
}
protected override void When()
{
SystemUnderTest.AddMessagePublisher <Message>(null, string.Empty);
SystemUnderTest.AddMessagePublisher <Message>(null, string.Empty);
}
protected override void When()
{
SystemUnderTest.AddNotificationSubscriber("region1", _subscriber1);
SystemUnderTest.Start();
SystemUnderTest.Stop();
}
protected override void When()
{
// Need to mock the results... so random isnt so random here...otherwise we get a test fail when comparing the formatted string...
SystemUnderTest.Timing(_someValueToSend, _sampleRate, _someBucketName);
}
protected override void When()
{
SystemUnderTest.Validate();
}
protected override void When()
{
_result = SystemUnderTest.Timing(_someValueToSend, _someBucketName);
}
public void ThrowsMessageFormatNotSupportedWhenMessabeBodyIsUnserializable()
{
Assert.Throws <MessageFormatNotSupportedException>(() => SystemUnderTest.DeserializeMessage(messageBody));
}
protected override void When()
{
SystemUnderTest.AddSerialiser <Message>(Substitute.For <IMessageSerialiser>());
SystemUnderTest.AddSerialiser <Message>(Substitute.For <IMessageSerialiser>());
}
public async Task ExceptionIsThrown()
{
await Should.ThrowAsync <PublishException>(() => SystemUnderTest.PublishAsync(new SimpleMessage()));
}
public void CallingStartTwiceDoesNotStartListeningTwice()
{
SystemUnderTest.Start();
_subscriber1.Received(1).Listen();
_subscriber2.Received(1).Listen();
}
protected override void When() => SystemUnderTest.DispatchMessage(_sqsMessage).GetAwaiter().GetResult();
protected override Task When()
{
_isQueueCreated = SystemUnderTest.Create(new SqsBasicConfiguration(), attempt: 0);
return(Task.CompletedTask);
}
public StoryTellerUIFixture(SystemUnderTest system)
{
_system = system;
this["TheTestsAre"] = this["AddTest"].AsTable("The tests are").After(_system.ReloadProject);
}
protected override void When()
{
SystemUnderTest.HandleMessage(null);
}
