public void Handlers_Can_Be_Unsubscribed()
{
var pub = new Publisher();
var calledSubscribers = new List<int>();
var sub1 = new InstanceSubscriber(1, pub, calledSubscribers.Add);
var sub2 = new InstanceSubscriber(2, pub, calledSubscribers.Add);
StaticSubscriber.FooWasRaised = false;
StaticSubscriber.Subscribe(pub);
// Make sure they really were subscribed
pub.Raise();
calledSubscribers.Should().Equal(1, 2);
StaticSubscriber.FooWasRaised.Should().BeTrue();
calledSubscribers.Clear();
sub1.Unsubscribe(pub);
pub.Raise();
calledSubscribers.Should().Equal(2);
StaticSubscriber.FooWasRaised = false;
StaticSubscriber.Unsubscribe(pub);
pub.Raise();
StaticSubscriber.FooWasRaised.Should().BeFalse();
calledSubscribers.Clear();
sub2.Unsubscribe(pub);
pub.Raise();
calledSubscribers.Should().BeEmpty();
// Make sure subscribers are not collected before the end of the test
GC.KeepAlive(sub1);
GC.KeepAlive(sub2);
}
public async Task InstallPackageTest() {
await Workflow.RSession.EnsureHostStartedAsync(new RHostStartupInfo {Name = nameof(InstallPackageTest)}, null, 50000);
var completionSets = new List<CompletionSet>();
for (int i = 0; i < 2; i++) {
try {
await Workflow.Packages.UninstallPackageAsync("abc", null);
//await Workflow.RSession.ExecuteAsync("remove.packages('abc')", REvaluationKind.Mutating);
} catch (RException) { }
await PackageIndex.BuildIndexAsync();
completionSets.Clear();
RCompletionTestUtilities.GetCompletions(EditorShell, "abc::", 5, completionSets);
completionSets.Should().ContainSingle();
// Try again one more time
if (completionSets[0].Completions.Count == 0) {
break;
}
}
completionSets[0].Completions.Should().BeEmpty();
try {
await Workflow.RSession.ExecuteAsync("install.packages('abc')", REvaluationKind.Mutating);
} catch (RException) { }
await PackageIndex.BuildIndexAsync();
completionSets.Clear();
RCompletionTestUtilities.GetCompletions(EditorShell, "abc::", 5, completionSets);
completionSets.Should().ContainSingle();
completionSets[0].Completions.Should().NotBeEmpty();
}
public void Should_fluent_assertions()
{
object obj = null;
obj.Should().Be.Null();
obj = new object();
obj.Should().Be.OfType(typeof(object));
obj.Should().Equal(obj);
obj.Should().Not.Be.Null();
obj.Should().Not.Be.SameAs(new object());
obj.Should().Not.Be.OfType<string>();
obj.Should().Not.Equal("foo");
obj = "x";
obj.Should().Not.Be.InRange("y", "z");
obj.Should().Be.InRange("a", "z");
obj.Should().Be.SameAs("x");
"This String".Should().Contain("This");
"This String".Should().Not.Be.Empty();
"This String".Should().Not.Contain("foobar");
false.Should().Be.False();
true.Should().Be.True();
var list = new List<object>();
list.Should().Count.Zero();
list.Should().Not.Contain.Item(new object());
var item = new object();
list.Add(item);
list.Should().Not.Be.Empty();
list.Should().Contain.Item(item);
}
public void Given_Action_And_Strings_When_Calling_Each_Then_Action_Is_Invoked_For_Each_Element()
{
IEnumerable<int> items = new List<int> { 1, 2, 3 };
var visited = new List<int>();
Action<int> action = visited.Add;
items.Each(action);
visited.Should().ContainInOrder(items);
visited.Should().HaveCount(items.Count());
}
public void InstallTelemetry() {
var telemetryEvents = new List<string>();
var telemetry = Substitute.For<ITelemetryService>();
telemetry.When(x => x.ReportEvent(Arg.Any<TelemetryArea>(), Arg.Any<string>(), Arg.Any<object>()))
.Do(x => telemetryEvents.Add(x.Args()[1] as string));
var coreShell = Substitute.For<ICoreShell>();
var services = Substitute.For<ICoreServices>();
services.Telemetry.Returns(telemetry);
var ps = Substitute.For<IProcessServices>();
ps.When(x => x.Start(Arg.Any<string>())).Do(c => {
c.Args()[0].Should().NotBeNull();
});
services.ProcessServices.Returns(ps);
coreShell.Services.Returns(services);
coreShell.ShowMessage(Arg.Any<string>(), Arg.Any<MessageButtons>()).Returns(MessageButtons.Yes);
var downloader = Substitute.For<IFileDownloader>();
downloader.Download(null, null, CancellationToken.None).ReturnsForAnyArgs((string)null);
var inst = new MicrosoftRClientInstaller();
inst.LaunchRClientSetup(coreShell, downloader);
telemetryEvents.Should().HaveCount(1);
telemetryEvents[0].Should().Be(RtvsTelemetry.ConfigurationEvents.RClientInstallYes);
downloader.Download(null, null, CancellationToken.None).ReturnsForAnyArgs("Failed");
telemetryEvents.Clear();
inst.LaunchRClientSetup(coreShell, downloader);
telemetryEvents.Should().HaveCount(2);
telemetryEvents[0].Should().Be(RtvsTelemetry.ConfigurationEvents.RClientInstallYes);
telemetryEvents[1].Should().Be(RtvsTelemetry.ConfigurationEvents.RClientDownloadFailed);
downloader.Download(null, null, CancellationToken.None).ReturnsForAnyArgs((string)null);
ps = Substitute.For<IProcessServices>();
ps.When(x => x.Start(Arg.Any<string>())).Do(c => {
throw new Win32Exception((unchecked((int)0x800704C7)));
});
services.ProcessServices.Returns(ps);
telemetryEvents.Clear();
inst.LaunchRClientSetup(coreShell, downloader);
telemetryEvents.Should().HaveCount(2);
telemetryEvents[0].Should().Be(RtvsTelemetry.ConfigurationEvents.RClientInstallYes);
telemetryEvents[1].Should().Be(RtvsTelemetry.ConfigurationEvents.RClientInstallCancel);
}
public void NewValidationRulesShouldBeInTheRuleSetExceptBaselinedExceptionRules()
{
var validationRules = new Dictionary<object, string>();
var items = typeof(ValidationRules).GetFields().Select(f=> new KeyValuePair<object, string>(f.GetValue(null), f.Name));
foreach (var item in items)
{
validationRules.Add(item.Key, item.Value);
}
var unFoundValidationRules = new List<object>();
foreach(var ruleSet in ValidationRuleSet.GetEdmModelRuleSet(new Version(4, 0)))
{
if (validationRules.ContainsKey(ruleSet))
{
validationRules.Remove(ruleSet);
}
else
{
unFoundValidationRules.Add(validationRules);
}
}
unFoundValidationRules.Should().HaveCount(0);
// The 4 remaining rules are deprecated:
// ComplexTypeMustContainProperties
// OnlyEntityTypesCanBeOpen
// ComplexTypeInvalidPolymorphicComplexType
// ComplexTypeInvalidAbstractComplexType
validationRules.ToList().Should().HaveCount(4);
}
public void JsonReader_should_support_reading_multiple_documents(
[Range(0, 3)]
int numberOfDocuments)
{
var document = new BsonDocument("x", 1);
var json = document.ToJson();
var input = Enumerable.Repeat(json, numberOfDocuments).Aggregate("", (a, j) => a + j);
var expectedResult = Enumerable.Repeat(document, numberOfDocuments);
using (var jsonReader = new JsonReader(input))
{
var result = new List<BsonDocument>();
while (!jsonReader.IsAtEndOfFile())
{
jsonReader.ReadStartDocument();
var name = jsonReader.ReadName();
var value = jsonReader.ReadInt32();
jsonReader.ReadEndDocument();
var resultDocument = new BsonDocument(name, value);
result.Add(resultDocument);
}
result.Should().Equal(expectedResult);
}
}
public void Should_calculate_retry_timespans_from_current_retry_attempt_and_timespan_provider()
{
var expectedRetryCounts = new[]
{
2.Seconds(),
4.Seconds(),
8.Seconds(),
16.Seconds(),
32.Seconds()
};
var retryTimeSpans = new List<TimeSpan>();
var policy = Policy
.Handle<DivideByZeroException>()
.WaitAndRetry(5,
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
(_, timeSpan) => retryTimeSpans.Add(timeSpan)
);
policy.RaiseException<DivideByZeroException>(5);
retryTimeSpans.Should()
.ContainInOrder(expectedRetryCounts);
}
public void FunctionDefinition01() {
var completionSets = new List<CompletionSet>();
RCompletionTestUtilities.GetCompletions(_editorShell, "x <- function()", 14, completionSets);
completionSets.Should().ContainSingle()
.Which.Completions.Should().BeEmpty();
}
public void SuppressedCompletion(string content, int position) {
var completionSets = new List<CompletionSet>();
RCompletionTestUtilities.GetCompletions(_editorShell, content, position, completionSets);
completionSets.Should().ContainSingle()
.Which.Completions.Should().BeEmpty();
}
public void BeforeComment() {
var completionSets = new List<CompletionSet>();
RCompletionTestUtilities.GetCompletions(_editorShell, "#No", 0, completionSets);
completionSets.Should().ContainSingle()
.Which.Completions.Should().NotBeEmpty();
}
public void ResponsePropertyCollectionsShouldBeReadOnly()
{
var exceptions = new HashSet<PropertyInfo>
{
typeof(ITypeMapping).GetProperty(nameof(ITypeMapping.DynamicDateFormats)),
typeof(ITypeMapping).GetProperty(nameof(ITypeMapping.Meta)),
typeof(TypeMapping).GetProperty(nameof(TypeMapping.DynamicDateFormats)),
typeof(TypeMapping).GetProperty(nameof(TypeMapping.Meta)),
#pragma warning disable 618
typeof(IMultiPercolateResponse).GetProperty(nameof(IMultiPercolateResponse.Responses)),
#pragma warning restore 618
typeof(IBulkResponse).GetProperty(nameof(IBulkResponse.ItemsWithErrors)),
typeof(IMultiSearchResponse).GetProperty(nameof(IMultiSearchResponse.AllResponses)),
};
var responseInterfaceTypes = from t in typeof(IResponse).Assembly().Types()
where t.IsInterface() && typeof(IResponse).IsAssignableFrom(t)
select t;
var ruleBreakers = new List<string>();
var seenTypes = new HashSet<Type>();
foreach (var responseType in responseInterfaceTypes)
{
FindPropertiesBreakingRule(responseType, exceptions, seenTypes, ruleBreakers);
}
ruleBreakers.Should().BeEmpty();
}
public void RCompletionSource_CommentsTest01() {
List<CompletionSet> completionSets = new List<CompletionSet>();
GetCompletions("#No", 3, completionSets);
completionSets.Should().ContainSingle()
.Which.Completions.Should().BeEmpty();
}
public void InplaceUpdateRemoveAllTest() {
List<IntegerWrap> source = new List<IntegerWrap> { new IntegerWrap(1), new IntegerWrap(2), new IntegerWrap(3) };
List<IntegerWrap> update = new List<IntegerWrap>();
source.InplaceUpdate(update, IntegerComparer, ElementUpdater);
source.Should().Equal(update, IntegerComparer);
}
public void ReshufflesDiscards()
{
var cards = new List<int>();
for (int i = 0; i < 95; i++)
{
var card = _deck.DrawCard();
if (card%9 == 0)
{
cards.Add(card);
_deck.DiscardCard(card);
}
}
var shuffledDiscards = new List<int>();
for (int i = 0; i < cards.Count + 4; i++)
{
if (i > 3)
{
var card = _deck.DrawCard();
card.Satisfy(x => x%9 == 0);
shuffledDiscards.Add(card);
}
else
_deck.DrawCard();
}
cards.Should().Not.Have.SameSequenceAs(shuffledDiscards);
}
public void It_iterates_through_all_added_resolvers_in_order_when_they_return_null()
{
var compositeCommandResolver = new CompositeCommandResolver();
var resolverCalls = new List<int>();
var mockResolver1 = new Mock<ICommandResolver>();
mockResolver1.Setup(r => r
.Resolve(It.IsAny<CommandResolverArguments>()))
.Returns(default(CommandSpec))
.Callback(() => resolverCalls.Add(1));
var mockResolver2 = new Mock<ICommandResolver>();
mockResolver2.Setup(r => r
.Resolve(It.IsAny<CommandResolverArguments>()))
.Returns(default(CommandSpec))
.Callback(() => resolverCalls.Add(2));
compositeCommandResolver.AddCommandResolver(mockResolver1.Object);
compositeCommandResolver.AddCommandResolver(mockResolver2.Object);
compositeCommandResolver.Resolve(default(CommandResolverArguments));
resolverCalls.Should()
.HaveCount(2)
.And
.ContainInOrder(new [] {1, 2});
}
public void It_stops_iterating_through_added_resolvers_when_one_returns_nonnull()
{
var compositeCommandResolver = new CompositeCommandResolver();
var resolverCalls = new List<int>();
var mockResolver1 = new Mock<ICommandResolver>();
mockResolver1.Setup(r => r
.Resolve(It.IsAny<CommandResolverArguments>()))
.Returns(new CommandSpec(null, null, default(CommandResolutionStrategy)))
.Callback(() => resolverCalls.Add(1));
var mockResolver2 = new Mock<ICommandResolver>();
mockResolver2.Setup(r => r
.Resolve(It.IsAny<CommandResolverArguments>()))
.Returns(default(CommandSpec))
.Callback(() => resolverCalls.Add(2));
compositeCommandResolver.AddCommandResolver(mockResolver1.Object);
compositeCommandResolver.AddCommandResolver(mockResolver2.Object);
compositeCommandResolver.Resolve(default(CommandResolverArguments));
resolverCalls.Should()
.HaveCount(1)
.And
.ContainInOrder(new [] {1});
}
public void BaseFunctions01() {
var completionSets = new List<CompletionSet>();
RCompletionTestUtilities.GetCompletions(EditorShell, "", 0, completionSets);
completionSets.Should().ContainSingle()
.Which.Completions.Should().Contain(c => c.DisplayText == "abbreviate")
.And.Contain(c => c.DisplayText == "abs");
}
public void Shuffle_OrderChanges()
{
// In theory we could get back the exact same order- really unlikely, particularly with larger collections
int[] source = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List<int> items = new List<int>(source);
items.Shuffle();
items.Should().NotEqual(source);
}
public void RotateToHeadShouldWork()
{
var l = new List<int>() {1,2,3,4,5,6,7};
l = l.RotateToHead(n => n == 4);
l.Should().Equal(4, 5, 6, 7, 1, 2, 3);
}
public void RCompletionSource_BaseFunctionsTest01() {
List<CompletionSet> completionSets = new List<CompletionSet>();
GetCompletions("", 0, completionSets);
completionSets.Should().ContainSingle()
.Which.Completions.Should().Contain(c => c.DisplayText == "abbreviate")
.And.Contain(c => c.DisplayText == "abs");
}
public void ResolvesAllAssemblies()
{
var packagePath = Path.Combine(PackagesPath, F.DefaultPackageName, F.DefaultVersion);
var fileSystem = FileSystemMockBuilder.Create()
.AddFiles(packagePath, F.TwoAssemblies)
.Build();
var library = F.Create(assemblies: F.TwoAssemblies);
var resolver = new PackageCompilationAssemblyResolver(fileSystem, PackagesPath);
var assemblies = new List<string>();
var result = resolver.TryResolveAssemblyPaths(library, assemblies);
assemblies.Should().HaveCount(2);
assemblies.Should().Contain(Path.Combine(packagePath, F.DefaultAssemblyPath));
assemblies.Should().Contain(Path.Combine(packagePath, F.SecondAssemblyPath));
}
public void RtvsPackage() {
var completionSets = new List<CompletionSet>();
RCompletionTestUtilities.GetCompletions(EditorShell, "rtv", 3, completionSets, new TextRange(0, 3));
completionSets.Should().ContainSingle();
completionSets[0].Filter();
completionSets[0].Completions[0].DisplayText.Should().Be("rtvs");
}
public void FunctionDefinition02() {
for (int i = 14; i <= 18; i++) {
var completionSets = new List<CompletionSet>();
RCompletionTestUtilities.GetCompletions(_editorShell, "x <- function(a, b)", i, completionSets);
completionSets.Should().ContainSingle()
.Which.Completions.Should().BeEmpty();
}
}
public static void Verify(Project project, DiagnosticAnalyzer diagnosticAnalyzer)
{
var compilation = project.GetCompilationAsync().Result;
var compilationWithAnalyzer = GetDiagnostics(compilation, diagnosticAnalyzer);
var expected = new List<int>(ExpectedIssues(compilation.SyntaxTrees.First()));
foreach (var diagnostic in compilationWithAnalyzer
.Where(diag => diag.Id == diagnosticAnalyzer.SupportedDiagnostics.Single().Id))
{
var line = diagnostic.GetLineNumberToReport();
expected.Should().Contain(line);
expected.Remove(line);
}
expected.Should().BeEquivalentTo(Enumerable.Empty<int>());
}
public void doit()
{
var list = new List<string>();
var gameConnector = new GameConnector();
gameConnector.NewPosition += (sender, args) => list.Add(args.Board);
gameConnector.Connect();
Thread.Sleep(1000);
list.Should().NotBeEmpty();
}
public void RCompletionSource_SpecificPackageTest01() {
List<CompletionSet> completionSets = new List<CompletionSet>();
GetCompletions("utils::", 7, completionSets);
completionSets.Should().ContainSingle();
completionSets[0].Completions.Should().Contain(c => c.DisplayText == "adist")
.Which.Description.Should().Be("Approximate String Distances");
}
protected void ExpectClientsReceivedDeviceConfiguration()
{
var clientsWhoGotTheMessage = new List<IActorRef>();
Enumerable.Range(0, ClientProxies.Count).ForEach(i =>
{
ExpectMsg<DeviceConfiguration>((m, actor) => clientsWhoGotTheMessage.Add(actor));
});
clientsWhoGotTheMessage.Should().BeEquivalentTo(ClientProxies);
}
public void Packages01() {
var completionSets = new List<CompletionSet>();
RCompletionTestUtilities.GetCompletions(EditorShell, "lIbrAry(", 8, completionSets);
completionSets.Should().ContainSingle();
completionSets[0].Completions.Should().Contain(c => c.DisplayText == "base")
.Which.Description.Should().Be("Base R functions.");
}
public void RCompletionSource_PackagesTest01() {
List<CompletionSet> completionSets = new List<CompletionSet>();
GetCompletions("library(", 8, completionSets);
completionSets.Should().ContainSingle();
completionSets[0].Completions.Should().Contain(c => c.DisplayText == "base")
.Which.Description.Should().Be("Base R functions.");
}
public void Should_validate_Excel_table_and_return_casting_errors()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
ExcelTable table = excelPackage1.GetTable("TEST3");
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
List <ExcelExceptionArgs> validationResults = table.Validate <WrongCars>().ToList();
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
table.Should().NotBeNull("We have TEST3 table");
validationResults.Should().NotBeNull("We have errors here");
validationResults.Count.Should().Be(2, "We have 2 errors");
validationResults.Exists(x => x.CellAddress.Address.Equals("C6", StringComparison.InvariantCultureIgnoreCase)).Should().BeTrue("Toyota is not in the enumeration");
validationResults.Exists(x => x.CellAddress.Address.Equals("D7", StringComparison.InvariantCultureIgnoreCase)).Should().BeTrue("Date is null");
}
public void NullCoercedDateTimeTest()
{
TestDateTime = DateTime.MinValue.ToString("dd/MM/yyyy");
List <object> expected = new List <object> {
string.Empty
};
List <object> values = new List <object>();
MainOccupancyMapper mapper = new MainOccupancyMapper();
IValueProvider valueProvider = new ValueProvider();
valueProvider.GetFormattedValue(
values,
TestDateTime,
mapper,
new ModelProperty(
mapper.MemberMaps.Single(x => string.Equals(x.Data.Member.Name, nameof(MainOccupancyModel.DateOfBirth), StringComparison.Ordinal)).Data.Names.Names.ToArray(),
GetType().GetProperty(nameof(TestDateTime))));
values.Should().BeEquivalentTo(expected);
}
public static void ShouldBeSameEventsAs(this List <SyncState> actualEvents,
params SyncState[] expectedEvents)
{
Ensure.Argument.IsNotNull(expectedEvents, nameof(expectedEvents));
actualEvents.Should().HaveCount(expectedEvents.Length);
for (var i = 0; i < expectedEvents.Length; i++)
{
var actual = actualEvents[i];
var expected = expectedEvents[i];
try
{
actual.Should().Be(expected);
}
catch (Exception e)
{
throw new Exception($"Found unexpected event at index {i}.", e);
}
}
}
private void AssertFindsTestWithTraits(string displayName, Trait[] traits)
{
SampleTestToUse.AsFileInfo()
.Should().Exist("building the SampleTests solution produces that executable");
GoogleTestDiscoverer discoverer = new GoogleTestDiscoverer(TestEnvironment.Logger, TestEnvironment.Options);
List <TestCase> tests = discoverer.GetTestsFromExecutable(SampleTestToUse).ToList();
MockLogger.Verify(l => l.LogError(It.IsAny <string>()), Times.Never);
MockLogger.Verify(l => l.DebugError(It.IsAny <string>()), Times.Never);
tests.Should().NotBeEmpty();
TestCase testCase = tests.Find(tc => tc.Traits.Count == traits.Length && tc.DisplayName.StartsWith(displayName));
testCase.Should().NotBeNull($"Test should exist: {displayName}, {traits.Length} trait(s)");
foreach (Trait trait in traits)
{
Trait foundTrait = testCase.Traits.FirstOrDefault(T => trait.Name == T.Name && trait.Value == T.Value);
foundTrait.Should().NotBeNull("Didn't find trait: (" + trait.Name + ", " + trait.Value + ")");
}
}
public async Task Clear_group_from_user_writes_to_outbox()
{
// Arrange
DomainUser existingUser = _fakers.DomainUser.Generate();
existingUser.Group = _fakers.DomainGroup.Generate();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
await dbContext.ClearTableAsync <OutgoingMessage>();
dbContext.Users.Add(existingUser);
await dbContext.SaveChangesAsync();
});
var requestBody = new
{
data = (object)null
};
string route = $"/domainUsers/{existingUser.StringId}/relationships/group";
// Act
(HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecutePatchAsync <string>(route, requestBody);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
responseDocument.Should().BeEmpty();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
List <OutgoingMessage> messages = await dbContext.OutboxMessages.OrderBy(message => message.Id).ToListAsync();
messages.Should().HaveCount(1);
var content = messages[0].GetContentAs <UserRemovedFromGroupContent>();
content.UserId.Should().Be(existingUser.Id);
content.GroupId.Should().Be(existingUser.Group.Id);
});
}
public void EnumerableReturnsAllItems()
{
var items = new List <object>();
var sut = new BuildHistory();
for (var index = 0; index < 10; index++)
{
var item = Model.Create <Person>() !;
items.Add(item);
sut.Push(item);
}
items.Reverse();
foreach (var item in sut)
{
items.Should().Contain(item !);
}
}
protected void It_Should_Throw_On_All_Property_Setters_Implementation()
{
var unprotectedSetters = new List <string>();
foreach (var pi in _propertyInfos)
{
var propertyInfo = pi;
if (propertyInfo.CanWrite)
{
Action throwingAction = () => propertyInfo.SetValue(Target, GetDefaultValue(propertyInfo));
try
{
throwingAction.Should().Throw <TargetInvocationException>().WithInnerException <NotSupportedException>();
}
catch (AssertFailedException e)
{
unprotectedSetters.Add(
$"{Target.GetType().FullName}.{propertyInfo.Name} should throw TargetInvocationException(NotSupportedException) when read only and the property setter is invoked, " +
$"but the following was thrown by the test:\r\n{e}.");
}
catch (Exception e)
{
unprotectedSetters.Add(
$"{Target.GetType().FullName}.{propertyInfo.Name} should throw TargetInvocationException(NotSupportedException) when read only and the property setter is invoked, " +
$"but it did throw:\r\n{e}.");
}
}
}
if (unprotectedSetters.Any())
{
foreach (var unprotected in unprotectedSetters)
{
Trace.WriteLine(unprotected);
}
}
unprotectedSetters.Should().BeEmpty();
}
public void QueryTransactions_ShouldAllowFilteringBySearchString(string searchValue)
{
var request = TestHelper.GetQueryRequest(searchValue);
var response = CheckoutClient.ReportingService.QueryTransaction(request);
response.Should().NotBeNull();
response.HttpStatusCode.Should().Be(HttpStatusCode.OK);
response.Model.TotalRecords.Should().BeGreaterThan(0);
// the following fields will be checked if they contain the input search value:
var assertions = new List <bool>
{
response.Model.Data.Any(d => d.Id.Contains(request.Search, _ignoreCase)),
response.Model.Data.Any(d => d.OriginId.Contains(request.Search, _ignoreCase)),
response.Model.Data.Any(d => d.TrackId.Contains(request.Search, _ignoreCase)),
response.Model.Data.Any(d => d.Status.Contains(request.Search, _ignoreCase)),
response.Model.Data.Any(d => d.Customer.Email.Contains(request.Search, _ignoreCase))
};
// at least one of the fields contains the search value
assertions.Should().Contain(assert => assert);
}
public async Task SimpleIntInt()
{
var provider = TestHelper.BuildServiceProviderUdp("127.0.0.1", 1784, helper);
using (provider as IDisposable)
{
var p1 = provider.GetRequiredService <IDistributedPublisher <int, int> >();
var s1 = provider.GetRequiredService <IDistributedSubscriber <int, int> >();
var result = new List <int>();
await s1.SubscribeAsync(1, x =>
{
result.Add(x);
});
var result2 = new List <int>();
await s1.SubscribeAsync(4, x =>
{
result2.Add(x);
});
await Task.Delay(TimeSpan.FromSeconds(1)); // wait for receive data...
await p1.PublishAsync(1, 9999);
await Task.Delay(TimeSpan.FromSeconds(1)); // wait for receive data...
await p1.PublishAsync(4, 888);
await Task.Delay(TimeSpan.FromSeconds(1)); // wait for receive data...
await p1.PublishAsync(1, 4999);
await Task.Delay(TimeSpan.FromSeconds(1)); // wait for receive data...
result.Should().Equal(9999, 4999);
result2.Should().Equal(888);
}
}
public async void Pets_Not_Exists()
{
var mock = new ServiceMockFacade <IClientRepository>();
mock.RepositoryMock.Setup(x => x.Pets(default(int), It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult <List <Pet> >(new List <Pet>()));
var service = new ClientService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.ClientModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLClientMapperMock,
mock.DALMapperMockFactory.DALClientMapperMock,
mock.BOLMapperMockFactory.BOLClientCommunicationMapperMock,
mock.DALMapperMockFactory.DALClientCommunicationMapperMock,
mock.BOLMapperMockFactory.BOLPetMapperMock,
mock.DALMapperMockFactory.DALPetMapperMock,
mock.BOLMapperMockFactory.BOLSaleMapperMock,
mock.DALMapperMockFactory.DALSaleMapperMock);
List <ApiPetResponseModel> response = await service.Pets(default(int));
response.Should().BeEmpty();
mock.RepositoryMock.Verify(x => x.Pets(default(int), It.IsAny <int>(), It.IsAny <int>()));
}
public async Task WhenClosingAConnection_ItShouldRaiseClosingAndClosedEvents(Protocol protocol)
{
var client = await GetRealtimeClient(protocol);
//Start collecting events after the connection is open
await WaitForState(client);
var states = new List <ConnectionState>();
client.Connection.InternalStateChanged += (sender, args) =>
{
args.Should().BeOfType <ConnectionStateChange>();
states.Add(args.Current);
};
client.Close();
await WaitForState(client, ConnectionState.Closed, TimeSpan.FromSeconds(5));
states.Should().BeEquivalentTo(new[] { ConnectionState.Closing, ConnectionState.Closed });
client.Connection.State.Should().Be(ConnectionState.Closed);
}
public void Execute_should_find_all_the_documents_matching_the_query_when_max_staleness_is_used(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.MaxStaleness);
EnsureTestData();
var subject = new FindOperation <BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var readPreference = new ReadPreference(ReadPreferenceMode.SecondaryPreferred, maxStaleness: TimeSpan.FromSeconds(90));
// the count could be short temporarily until replication catches up
List <BsonDocument> result = null;
SpinWait.SpinUntil(() =>
{
var cursor = ExecuteOperation(subject, readPreference, async);
result = ReadCursorToEnd(cursor, async);
return(result.Count >= 5);
},
TimeSpan.FromSeconds(10));
result.Should().HaveCount(5);
}
public async void SalesOrderHeaderSalesReasons_Exists()
{
var mock = new ServiceMockFacade <ISalesOrderHeaderRepository>();
var records = new List <SalesOrderHeaderSalesReason>();
records.Add(new SalesOrderHeaderSalesReason());
mock.RepositoryMock.Setup(x => x.SalesOrderHeaderSalesReasons(default(int), It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
var service = new SalesOrderHeaderService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.SalesOrderHeaderModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLSalesOrderHeaderMapperMock,
mock.DALMapperMockFactory.DALSalesOrderHeaderMapperMock,
mock.BOLMapperMockFactory.BOLSalesOrderDetailMapperMock,
mock.DALMapperMockFactory.DALSalesOrderDetailMapperMock,
mock.BOLMapperMockFactory.BOLSalesOrderHeaderSalesReasonMapperMock,
mock.DALMapperMockFactory.DALSalesOrderHeaderSalesReasonMapperMock);
List <ApiSalesOrderHeaderSalesReasonResponseModel> response = await service.SalesOrderHeaderSalesReasons(default(int));
response.Should().NotBeEmpty();
mock.RepositoryMock.Verify(x => x.SalesOrderHeaderSalesReasons(default(int), It.IsAny <int>(), It.IsAny <int>()));
}
public void StreamsCanBeSentToListeningWithProgressReporting()
{
using (var octopus = new HalibutRuntime(services, Certificates.Octopus))
using (var tentacleListening = new HalibutRuntime(services, Certificates.TentacleListening))
{
var tentaclePort = tentacleListening.Listen();
tentacleListening.Trust(Certificates.OctopusPublicThumbprint);
var progressReported = new List <int>();
var data = new byte[1024 * 1024 * 16 + 15];
new Random().NextBytes(data);
var stream = new MemoryStream(data);
var echo = octopus.CreateClient <IEchoService>("https://localhost:" + tentaclePort, Certificates.TentacleListeningPublicThumbprint);
var count = echo.CountBytes(DataStream.FromStream(stream, progressReported.Add));
count.Should().Be(1024 * 1024 * 16 + 15);
progressReported.Should().ContainInOrder(Enumerable.Range(1, 100));
}
}
public void GetValidEndPoints_should_raise_sdamInformationEvent_for_each_invalid_host(string[] srvEndPoints, string[] invalidHosts)
{
var lookupDomainName = "a.b.com";
var mockEventSubscriber = new Mock <IEventSubscriber>();
var actualEvents = new List <SdamInformationEvent>();
var sdamInformationEventHandler = (Action <SdamInformationEvent>)(raisedEvent => actualEvents.Add(raisedEvent));
mockEventSubscriber
.Setup(m => m.TryGetEventHandler <SdamInformationEvent>(out sdamInformationEventHandler));
var subject = CreateSubject(lookupDomainName: lookupDomainName, eventSubscriber: mockEventSubscriber.Object);
var srvRecords = CreateSrvRecords(srvEndPoints);
var result = subject.GetValidEndPoints(srvRecords);
actualEvents.Should().HaveCount(invalidHosts.Length);
for (var i = 0; i < actualEvents.Count; i++)
{
var actualEvent = actualEvents[i];
var invalidHost = invalidHosts[i];
actualEvent.Message.Should().Contain(invalidHost);
}
}
public async Task A_schedule_action_can_read_the_current_time_from_the_schedule()
{
var events = new List <DateTimeOffset>();
var startTime = DateTimeOffset.Parse("2018-04-01 1:00pm +00:00", CultureInfo.InvariantCulture);
using (var clock = VirtualClock.Start(startTime))
{
clock.Schedule(c => events.Add(c.Now()), 2.Seconds());
clock.Schedule(c => events.Add(c.Now()), 3.Seconds());
clock.Schedule(c => events.Add(c.Now()), 1.Hours());
await clock.AdvanceBy(20.Days());
}
events.Should().BeEquivalentTo(new[]
{
startTime.Add(2.Seconds()),
startTime.Add(3.Seconds()),
startTime.Add(1.Hours())
});
}
public async Task Publish_DelegateSubscriberReturnsMessagesArray_MessagesRepublished()
{
var republishedMessages = new List <object>();
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AddDelegateSubscriber(
(TestEventTwo _) => new ICommand[]
{
new TestCommandOne(),
new TestCommandTwo(),
new TestCommandOne()
})
.AddDelegateSubscriber((ICommand message) => republishedMessages.Add(message)));
var publisher = serviceProvider.GetRequiredService <IPublisher>();
publisher.Publish(new TestEventTwo());
await publisher.PublishAsync(new TestEventTwo());
republishedMessages.Should().HaveCount(6);
}
public void TheMaximumVersionsAreSupported(string targetFrameworkIdentifier)
{
var project = new TestProject
{
Name = "packagethatwillgomissing",
TargetFrameworks = targetFrameworkIdentifier == ".NETCoreApp" ? "netcoreapp2.0" : "netstandard2.0",
IsSdkProject = true,
};
TestAsset asset = _testAssetsManager
.CreateTestProject(project, identifier: targetFrameworkIdentifier);
string testDirectory = Path.Combine(asset.TestRoot, project.Name);
var getMaximumVersion = new GetValuesCommand(
Log,
testDirectory,
project.TargetFrameworks,
targetFrameworkIdentifier.Substring(1) + "MaximumVersion",
GetValuesCommand.ValueType.Property);
var getSupportedFrameworks = new GetValuesCommand(
Log,
testDirectory,
project.TargetFrameworks,
"SupportedTargetFramework",
GetValuesCommand.ValueType.Item);
getMaximumVersion.DependsOnTargets = "";
getMaximumVersion.Execute().Should().Pass();
getSupportedFrameworks.DependsOnTargets = "";
getSupportedFrameworks.Execute().Should().Pass();
string maximumVersion = getMaximumVersion.GetValues().Single();
List <string> supportedFrameworks = getSupportedFrameworks.GetValues();
supportedFrameworks.Should().Contain($"{targetFrameworkIdentifier},Version=v{maximumVersion}");
}
public void Should_write_and_read_bit_sequences()
{
var bitSequence = GenerateUnalignedBitSequence();
WriteBitSequence(bitSequence);
_writer.Flush();
_stream.Seek(0, SeekOrigin.Begin);
var read = new List <bool>();
while (!_reader.IsEndOfStream)
{
read.Add(_reader.ReadBit());
}
var alignedSequence = Align(bitSequence);
read.Should()
.HaveCount(alignedSequence.Count)
.And.ContainInOrder(alignedSequence);
}
protected static void AllShouldHaveCorrectAttributes(List <LogRecord> logRecords, string format)
{
var expectedAttributesForLogRecord = new LogRecord();
expectedAttributesForLogRecord.Attributes.Add(
new KeyValue
{
Key = "com.splunk.sourcetype",
Value = new AnyValue {
StringValue = "otel.profiling"
}
});
expectedAttributesForLogRecord.Attributes.Add(
new KeyValue
{
Key = "source.event.period",
Value = new AnyValue {
IntValue = 1000L
}
});
expectedAttributesForLogRecord.Attributes.Add(
new KeyValue
{
Key = "profiling.data.format",
Value = new AnyValue {
StringValue = format
}
});
expectedAttributesForLogRecord.Attributes.Add(
new KeyValue
{
Key = "profiling.data.type",
Value = new AnyValue {
StringValue = "cpu"
}
});
logRecords.Should().AllBeEquivalentTo(expectedAttributesForLogRecord, option => option.Including(x => x.Attributes));
}
public async void All()
{
var mock = new ServiceMockFacade <ILessonRepository>();
var records = new List <Lesson>();
records.Add(new Lesson());
mock.RepositoryMock.Setup(x => x.All(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
var service = new LessonService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.LessonModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLLessonMapperMock,
mock.DALMapperMockFactory.DALLessonMapperMock,
mock.BOLMapperMockFactory.BOLLessonXStudentMapperMock,
mock.DALMapperMockFactory.DALLessonXStudentMapperMock,
mock.BOLMapperMockFactory.BOLLessonXTeacherMapperMock,
mock.DALMapperMockFactory.DALLessonXTeacherMapperMock);
List <ApiLessonResponseModel> response = await service.All();
response.Should().HaveCount(1);
mock.RepositoryMock.Verify(x => x.All(It.IsAny <int>(), It.IsAny <int>()));
}
public async void All()
{
var mock = new ServiceMockFacade <IProvinceRepository>();
var records = new List <Province>();
records.Add(new Province());
mock.RepositoryMock.Setup(x => x.All(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
var service = new ProvinceService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.ProvinceModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLProvinceMapperMock,
mock.DALMapperMockFactory.DALProvinceMapperMock,
mock.BOLMapperMockFactory.BOLCityMapperMock,
mock.DALMapperMockFactory.DALCityMapperMock,
mock.BOLMapperMockFactory.BOLVenueMapperMock,
mock.DALMapperMockFactory.DALVenueMapperMock);
List <ApiProvinceResponseModel> response = await service.All();
response.Should().HaveCount(1);
mock.RepositoryMock.Verify(x => x.All(It.IsAny <int>(), It.IsAny <int>()));
}
public async Task commands_targeting_compositeKernel_are_not_routed_to_childKernels()
{
var receivedOnFakeKernel = new List <IKernelCommand>();
using var kernel = new CompositeKernel
{
new FakeKernel("fake")
{
Handle = (kernelCommand, context) =>
{
receivedOnFakeKernel.Add(kernelCommand);
return(Task.CompletedTask);
}
}
};
var submitCode = new SubmitCode("//command", kernel.Name);
await kernel.SendAsync(submitCode);
receivedOnFakeKernel.Should()
.BeEmpty();
}
public void GetAllAuctions_ExpectList()
{
// Arrange
Mock <IRestClient> restClient = new Mock <IRestClient>();
restClient.Setup(x => x.Execute <List <Auction> >(It.Is <IRestRequest>(r => r.Resource == APIService.API_URL), Method.GET))
.Returns(new RestResponse <List <Auction> >
{
StatusCode = HttpStatusCode.OK,
Data = expectedAuctions,
ResponseStatus = ResponseStatus.Completed
});
apiService.client = restClient.Object;
// Act
List <Auction> actualAuctions = apiService.GetAllAuctions();
// Assert
APIService.API_URL.Should().Be(EXPECTED_API_URL);
restClient.Verify(x => x.Execute <List <Auction> >(It.Is <IRestRequest>(r => r.Resource == EXPECTED_API_URL), Method.GET), Times.Once());
actualAuctions.Should().BeEquivalentTo(expectedAuctions);
}
public void ZeroIntTest()
{
TestInt = 0;
List <object> expected = new List <object> {
string.Empty
};
List <object> values = new List <object>();
MainOccupancyMapper mapper = new MainOccupancyMapper();
IValueProvider valueProvider = new ValueProvider();
valueProvider.GetFormattedValue(
values,
TestInt,
mapper,
new ModelProperty(
mapper.MemberMaps.Single(x => string.Equals(x.Data.Member.Name, nameof(MainOccupancyModel.CompStatus), StringComparison.Ordinal)).Data.Names.Names.ToArray(),
GetType().GetProperty(nameof(TestInt))));
values.Should().BeEquivalentTo(expected);
}
public void ShouldGenerateFiveDefaultEncrypting()
{
_options.Setup(s => s.Value).Returns(new JwksOptions()
{
KeyPrefix = $"{nameof(JsonWebKeySetServiceTests)}_"
});
_store.Clear();
var keysGenerated = new List <EncryptingCredentials>();
for (int i = 0; i < 5; i++)
{
var sign = _jwksService.GenerateEncryptingCredentials();
keysGenerated.Add(sign);
}
var current = _jwksService.GetLastKeysCredentials(JsonWebKeyType.Jwe, 5);
foreach (var securityKey in current)
{
keysGenerated.Should().Contain(s => s.Key.KeyId == securityKey.KeyId);
}
}
public async void OtherTransports_Not_Exists()
{
var mock = new ServiceMockFacade <IHandlerRepository>();
mock.RepositoryMock.Setup(x => x.OtherTransports(default(int), It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult <List <OtherTransport> >(new List <OtherTransport>()));
var service = new HandlerService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.HandlerModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLHandlerMapperMock,
mock.DALMapperMockFactory.DALHandlerMapperMock,
mock.BOLMapperMockFactory.BOLAirTransportMapperMock,
mock.DALMapperMockFactory.DALAirTransportMapperMock,
mock.BOLMapperMockFactory.BOLHandlerPipelineStepMapperMock,
mock.DALMapperMockFactory.DALHandlerPipelineStepMapperMock,
mock.BOLMapperMockFactory.BOLOtherTransportMapperMock,
mock.DALMapperMockFactory.DALOtherTransportMapperMock);
List <ApiOtherTransportResponseModel> response = await service.OtherTransports(default(int));
response.Should().BeEmpty();
mock.RepositoryMock.Verify(x => x.OtherTransports(default(int), It.IsAny <int>(), It.IsAny <int>()));
}
public async void Venues_Exists()
{
var mock = new ServiceMockFacade <IProvinceRepository>();
var records = new List <Venue>();
records.Add(new Venue());
mock.RepositoryMock.Setup(x => x.Venues(default(int), It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
var service = new ProvinceService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.ProvinceModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLProvinceMapperMock,
mock.DALMapperMockFactory.DALProvinceMapperMock,
mock.BOLMapperMockFactory.BOLCityMapperMock,
mock.DALMapperMockFactory.DALCityMapperMock,
mock.BOLMapperMockFactory.BOLVenueMapperMock,
mock.DALMapperMockFactory.DALVenueMapperMock);
List <ApiVenueResponseModel> response = await service.Venues(default(int));
response.Should().NotBeEmpty();
mock.RepositoryMock.Verify(x => x.Venues(default(int), It.IsAny <int>(), It.IsAny <int>()));
}
public async void ProductModelProductDescriptionCulturesByProductModelID_Exists()
{
var mock = new ServiceMockFacade <IProductModelRepository>();
var records = new List <ProductModelProductDescriptionCulture>();
records.Add(new ProductModelProductDescriptionCulture());
mock.RepositoryMock.Setup(x => x.ProductModelProductDescriptionCulturesByProductModelID(default(int), It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
var service = new ProductModelService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.ProductModelModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLProductModelMapperMock,
mock.DALMapperMockFactory.DALProductModelMapperMock,
mock.BOLMapperMockFactory.BOLProductMapperMock,
mock.DALMapperMockFactory.DALProductMapperMock,
mock.BOLMapperMockFactory.BOLProductModelProductDescriptionCultureMapperMock,
mock.DALMapperMockFactory.DALProductModelProductDescriptionCultureMapperMock);
List <ApiProductModelProductDescriptionCultureResponseModel> response = await service.ProductModelProductDescriptionCulturesByProductModelID(default(int));
response.Should().NotBeEmpty();
mock.RepositoryMock.Verify(x => x.ProductModelProductDescriptionCulturesByProductModelID(default(int), It.IsAny <int>(), It.IsAny <int>()));
}
public async void All()
{
var mock = new ServiceMockFacade <IFamilyRepository>();
var records = new List <Family>();
records.Add(new Family());
mock.RepositoryMock.Setup(x => x.All(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
var service = new FamilyService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.FamilyModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLFamilyMapperMock,
mock.DALMapperMockFactory.DALFamilyMapperMock,
mock.BOLMapperMockFactory.BOLStudentMapperMock,
mock.DALMapperMockFactory.DALStudentMapperMock,
mock.BOLMapperMockFactory.BOLStudentXFamilyMapperMock,
mock.DALMapperMockFactory.DALStudentXFamilyMapperMock);
List <ApiFamilyResponseModel> response = await service.All();
response.Should().HaveCount(1);
mock.RepositoryMock.Verify(x => x.All(It.IsAny <int>(), It.IsAny <int>()));
}
