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