private static async Task <AssessmentResult <TResult> > CallAssessment <TResult>( string methodName, SqlObjectType sqlObjectType, LiveConnectionHelper.TestConnectionResult liveConnection) where TResult : AssessmentItemInfo { var connInfo = liveConnection.ConnectionInfo; AssessmentResult <TResult> response; using (var service = new SqlAssessmentService( TestServiceProvider.Instance.ConnectionService, TestServiceProvider.Instance.WorkspaceService)) { AddTestRules(service); string randomUri = Guid.NewGuid().ToString(); AssessmentParams requestParams = new AssessmentParams { OwnerUri = randomUri, TargetType = sqlObjectType }; ConnectParams connectParams = new ConnectParams { OwnerUri = requestParams.OwnerUri, Connection = connInfo.ConnectionDetails, Type = ConnectionType.Default }; var methodInfo = typeof(SqlAssessmentService).GetMethod( methodName, BindingFlags.Instance | BindingFlags.NonPublic); Assert.NotNull(methodInfo); var func = (AssessmentMethod <TResult>)Delegate.CreateDelegate( typeof(AssessmentMethod <TResult>), service, methodInfo); response = await service.CallAssessmentEngine <TResult>( requestParams, connectParams, randomUri, t => func(t)); } Assert.NotNull(response); if (response.Success) { Assert.All( response.Items, i => { Assert.Equal(sqlObjectType, i.TargetType); Assert.Contains(i.Level, AllowedSeverityLevels); }); } return(response); }
public void UrlMatchFilterMatchAcceptAllSuccessTest() { #region Test Setup var fakeScenario = scenarioFaker.Generate(); fakeScenario.RequestMatchRules.UrlRules = fakeScenario.RequestMatchRules.UrlRules.Select(r => { r.Type = ComparerType.ACCEPTALL; return(r); }).ToList(); var faker = new Faker(); var input = new { Scenarios = new List <Scenario>() { fakeScenario }, Path = faker.Random.AlphaNumeric(TestUtils.GetRandomStringLength()) }; #endregion var Target = new UrlMatchFilter <ProcessMessagePort>(new AssertFactory(), new RuleMatcher()); var port = new ProcessMessagePort() { Scenarios = input.Scenarios, Path = input.Path }; var Actual = Target.Process(port).URLMatchResults .Where(x => x.Match.Equals(MatchResultType.Success)).Select(x => x.ScenarioId).ToList(); var Expected = fakeScenario.Id; Assert.Contains(Expected, Actual); }
public void UpdateKeysCollectionExistingKeySuccessTest() { #region Test Setup var metadataFake = new Faker <MetadataInfo>() .RuleFor(m => m.Title, f => f.Lorem.Sentence()) .RuleFor(m => m.Description, f => f.Lorem.Paragraph()); var mockDefinitionFake = new Faker <MockDefinition>() .RuleFor(m => m.Host, f => f.Internet.DomainName()) .RuleFor(m => m.Metadata, f => metadataFake.Generate()); var options = new MemoryCacheOptions(); var cache = new MemoryCache(options); var input = new { mockDefinition = mockDefinitionFake.Generate() }; var updateMockDefinitionCommand = new UpdateMockDefinitionByTitleCommand(input.mockDefinition, ref TestUtils.databaseLock); #endregion cache.Set(input.mockDefinition.Metadata.Title, input.mockDefinition); cache.Set(data.mockIds, new List <string> { input.mockDefinition.Metadata.Title }); var Target = new UpdateMockDefinitionHandler(cache, data); Target.Handle(updateMockDefinitionCommand, CancellationToken.None); var Actual = cache.Get <List <string> >(data.mockIds); Assert.Contains(input.mockDefinition.Metadata.Title, Actual); }
public void ResponseSelectFilterSuccessMultipleResponseTest() { #region TestSetup var Scenarios = fakerScenario.Generate(10); var random = new Random(42); var SelectedScenariosRange = random.Next(2, Scenarios.Count); var SelectedScenariosStartIndex = random.Next(Scenarios.Count - SelectedScenariosRange); var SelectedScenarios = Scenarios.Skip(SelectedScenariosStartIndex).Take(SelectedScenariosRange).ToList(); var SelectedScenarioIndex = random.Next(Scenarios.Count); var PossibleResponses = SelectedScenarios.Select(s => s.Response); #endregion var port = new ProcessMessagePort() { Scenarios = Scenarios, HeaderMatchResults = Scenarios.Select(scenario => new MatchResult(MatchResultType.Success, scenario.Id, false)).ToList(), QueryMatchResults = Scenarios.Skip(SelectedScenarioIndex).Select(scenario => new MatchResult(MatchResultType.Success, scenario.Id, false)).ToList(), BodyMatchResults = Scenarios.Take(SelectedScenarioIndex + 1).Select(scenario => new MatchResult(MatchResultType.Success, scenario.Id, false)).ToList(), }; var Target = new ResponseSelectorFilter <ProcessMessagePort>(new TemplateContext()); var Actual = Target.Process(port).SelectedResponse; Assert.Contains(Actual, PossibleResponses); }
public void UrlMatchFilterMatchSuccessTest() { #region Test Setup var fakeScenario = scenarioFaker.Generate(); var faker = new Faker(); var input = new { Scenarios = new List <Scenario>() { fakeScenario }, Path = fakeScenario.RequestMatchRules.UrlRules.FirstOrDefault().RuleValue.Value }; #endregion var Target = new UrlMatchFilter <ProcessMessagePort>(new AssertFactory(), new RuleMatcher()); var port = new ProcessMessagePort() { Scenarios = input.Scenarios, Path = input.Path }; var Actual = Target.Process(port).URLMatchResults .Where(x => x.Match.Equals(MatchResultType.Success)).Select(x => x.ScenarioId).ToList(); var Expected = fakeScenario.Id; Assert.Contains(Expected, Actual); }
public void GetLatestCompanyProducers_ReturnsCurrentForComplianceYearCompaniesOnly() { using (DatabaseWrapper database = new DatabaseWrapper()) { ModelHelper helper = new ModelHelper(database.Model); // Arrange Scheme scheme1 = helper.CreateScheme(); MemberUpload memberUpload1 = helper.CreateMemberUpload(scheme1); memberUpload1.ComplianceYear = 2015; memberUpload1.IsSubmitted = true; ProducerSubmission companyProducer1 = helper.CreateProducerAsCompany(memberUpload1, "AA"); ProducerSubmission companyProducer2 = helper.CreateProducerAsCompany(memberUpload1, "BB"); ProducerSubmission companyProducer3 = helper.CreateProducerAsCompany(memberUpload1, "AA"); database.Model.SaveChanges(); // Act var result = ProducerQuerySet(database.WeeeContext).GetLatestCompanyProducers(); // Assert Assert.DoesNotContain(result, p => p.Id == companyProducer1.Id); Assert.Contains(result, p => p.Id == companyProducer2.Id); Assert.Contains(result, p => p.Id == companyProducer3.Id); } }
public void HeaderMatchRulesKeysAreEqualValuesAreDifferentFailure() { var fakeScenario = scenarioFaker.Generate(); var headers = fakeScenario.RequestMatchRules.HeaderRules.Select(x => new KeyValuePair <string, string>(x.RuleValue.Key, x.RuleValue.Value + "-unique")); var input = new { Scenarios = new List <Scenario>() { fakeScenario }, Headers = headers }; var Target = new HeaderMatchFilter <ProcessMessagePort>(assertFactory, ruleMatcher); var port = new ProcessMessagePort() { Scenarios = input.Scenarios, Headers = input.Headers }; var Actual = Target.Process(port).HeaderMatchResults.Where(x => x.Match == MatchResultType.Fail).Select(x => x.ScenarioId).ToList(); var Expected = fakeScenario.Id; Assert.Contains(Expected, Actual); }
public void HeaderMatchFilterMatchSuccessTest() { #region Test Setup var fakeScenario = scenarioFaker.Generate(); var headers = fakeScenario.RequestMatchRules.HeaderRules.Select(rules => rules.RuleValue); var input = new { Scenarios = new List <Scenario>() { fakeScenario }, Headers = headers }; #endregion var Target = new HeaderMatchFilter <ProcessMessagePort>(assertFactory, ruleMatcher); var port = new ProcessMessagePort() { Scenarios = input.Scenarios, Headers = input.Headers }; var Actual = Target.Process(port) .HeaderMatchResults.Where(x => x.Match.Equals(MatchResultType.Success)).Select(x => x.ScenarioId).ToList(); var Expected = fakeScenario.Id; Assert.Contains(Expected, Actual); }
public void Assertions() { var condition = false; var text = "something"; var obj = new Auto(); var tokens = new List <string> { "public", "void", "return" }; var zero = 8 - 8; var someEnumerable = new List <string>(); Assert.False(condition); Assert.Equal("something", text); Assert.NotEqual("something else", text); Assert.Contains("tech", "technology"); // also DoesNotContain Assert.Matches(".*thing$", "something"); Assert.Throws <DivideByZeroException>(() => 4 / zero); Assert.Empty(someEnumerable); // also NotEmpty Assert.IsType <Auto>(obj); Assert.Collection(new List <int> { 2, 4 }, n => Assert.Equal(2, n), n => Assert.Equal(4, n) ); Assert.All(new List <string> { "a", "ab", "abc" }, s => s.StartsWith("a")); }
public void GraphDTOFieldsTest() { GraphDTO dto = Misc.CreateGraphDTO(); Assert.True(dto.VertexMap.Count == 4); Assert.True(dto.VertexMap[0] == dto.Vertex(Misc.g1)); Assert.True(dto.VertexMap[1] == dto.Vertex(Misc.g2)); Assert.True(dto.VertexMap[2] == dto.Vertex(Misc.g3)); Assert.True(dto.VertexMap[3] == dto.Vertex(Misc.g4)); Assert.True(dto.VertexMap[0] == dto.Vertex(0)); Assert.True(dto.VertexMap[1] == dto.Vertex(1)); Assert.True(dto.VertexMap[2] == dto.Vertex(2)); Assert.True(dto.VertexMap[3] == dto.Vertex(3)); { VertexDTO[] successors = dto.Successors(dto.Vertex(0)).ToArray(); Assert.True(successors.Length == 2); Assert.Contains(dto.Vertex(1), successors); Assert.Contains(dto.Vertex(2), successors); } { VertexDTO[] successors = dto.Successors(dto.Vertex(1)).ToArray(); Assert.True(successors.Length == 1); Assert.Contains(dto.Vertex(3), successors); } { VertexDTO[] successors = dto.Successors(dto.Vertex(2)).ToArray(); Assert.True(successors.Length == 0); } }
public void DiGraphDTOFieldsTest() { DiGraphDTO dto = Misc.CreateDiGraphDTO(); Assert.True(dto.VertexMap.Count == 4); Assert.True(dto.VertexMap[0] == dto.Vertex(Misc.g1)); Assert.True(dto.VertexMap[1] == dto.Vertex(Misc.g2)); Assert.True(dto.VertexMap[2] == dto.Vertex(Misc.g3)); Assert.True(dto.VertexMap[3] == dto.Vertex(Misc.g4)); Assert.True(dto.VertexMap[0] == dto.Vertex(0)); Assert.True(dto.VertexMap[1] == dto.Vertex(1)); Assert.True(dto.VertexMap[2] == dto.Vertex(2)); Assert.True(dto.VertexMap[3] == dto.Vertex(3)); Assert.True(dto.Predecessors(dto.Vertex(1)).Count() == 1); Assert.True(dto.Predecessors(dto.Vertex(1)).ElementAt(0) == dto.Vertex(0)); Assert.True(dto.Predecessors(dto.Vertex(2)).Count() == 1); Assert.True(dto.Predecessors(dto.Vertex(2)).ElementAt(0) == dto.Vertex(0)); Assert.True(dto.Predecessors(dto.Vertex(3)).Count() == 2); Assert.Contains(dto.Vertex(1), dto.Predecessors(dto.Vertex(3))); Assert.Contains(dto.Vertex(2), dto.Predecessors(dto.Vertex(3))); }
public void Add_WithTheSameLocation_ReturnUnsuccessful( FriendService sut, Friend newFriend) { var myFriendsCollection = Builder <Friend> .CreateListOfSize(10).All() .TheFirst(1) .With(x => x.Name = "Sergio") .With(x => x.Location = new Location { Latitude = 10, Longitude = 10 }) .Build() .ToList(); sut.InMemoryCacheService.Remove(CacheKey); sut.InMemoryCacheService.Insert(CacheKey, myFriendsCollection); newFriend.Location.Latitude = 10; newFriend.Location.Longitude = 10; var result = sut.Add(newFriend); Assert.False(result.Succeeded); Assert.True(result.Reason == ServiceResultFailReason.BusinessValidation); Assert.Contains("Já existe um amigo nessa mesma localização.", result.Errors); }
public void Add_Should_AddVersionToCollection() { var v5_0 = new ApiVersion(5, 0); Versions.Add(v5_0); Assert.Contains(Versions, version => version == v5_0); }
public void Case2() { _page.UsernameInput("*****@*****.**"); _page.PasswordInput(""); _page.Submit(); Assert.Contains("The Password field is required.", _page.PasswordValidator); }
public void GetLatestCompanyProducers_ReturnsCompaniesOnly() { using (DatabaseWrapper database = new DatabaseWrapper()) { ModelHelper helper = new ModelHelper(database.Model); // Arrange Scheme scheme1 = helper.CreateScheme(); MemberUpload memberUpload1 = helper.CreateMemberUpload(scheme1); memberUpload1.ComplianceYear = 2015; memberUpload1.IsSubmitted = true; Weee.Tests.Core.Model.ProducerSubmission companyProducer1 = helper.CreateProducerAsCompany(memberUpload1, "AAAAAAA"); Weee.Tests.Core.Model.ProducerSubmission partnershipProducer = helper.CreateProducerAsPartnership(memberUpload1, "PPP1"); Weee.Tests.Core.Model.ProducerSubmission soleTraderProducer = helper.CreateProducerAsSoleTrader(memberUpload1, "SSS1"); Weee.Tests.Core.Model.ProducerSubmission companyProducer2 = helper.CreateProducerAsCompany(memberUpload1, "AAAAAAB"); database.Model.SaveChanges(); // Act var result = ProducerQuerySet(database.WeeeContext).GetLatestCompanyProducers(); // Assert Assert.Contains(result, p => p.Id == companyProducer1.Id); Assert.Contains(result, p => p.Id == companyProducer2.Id); Assert.DoesNotContain(result, p => p.Id == soleTraderProducer.Id); Assert.DoesNotContain(result, p => p.Id == partnershipProducer.Id); } }
public void BodyMatchContainsPartialTestSuccess() { #region var fakeScenario = scenarioFaker.Generate(); fakeScenario.RequestMatchRules.BodyRules = new List <BodyRule> { new BodyRule(ComparerType.JSONCONTAINS, JObject.Parse("{'a': 'b'}")) }; var input = new { Scenarios = new List <Scenario>() { fakeScenario }, Body = JObject.Parse("{'x': {'a': 'b'}}") }; #endregion var Target = new BodyMatchFilter <ProcessMessagePort>(new AssertFactory(), new RuleMatcher()); var Actual = Target.Process(new ProcessMessagePort() { Scenarios = input.Scenarios, Body = input.Body.ToString() }) .BodyMatchResults.Where(x => x.Match.Equals(MatchResultType.Success)).Select(x => x.ScenarioId); var Expected = fakeScenario.Id; Assert.Contains(Expected, Actual); }
public void BodyMatchFilterMatchFail() { #region var fakeScenario = scenarioFaker.Generate(); var input = new { Scenarios = new List <Scenario>() { fakeScenario }, Body = "{}" }; #endregion var Target = new BodyMatchFilter <ProcessMessagePort>(new AssertFactory(), new RuleMatcher()); var Actual = Target.Process(new ProcessMessagePort() { Scenarios = input.Scenarios, Body = input.Body }) .BodyMatchResults.Where(x => x.Match.Equals(MatchResultType.Fail)).Select(x => x.ScenarioId).ToList(); Assert.Contains(fakeScenario.Id, Actual); }
public void IsStringContainsSubstring() { var stringValue = "programming language"; var substring = "program"; Assert.Contains(substring, stringValue); }
public void Case1() { _page.UsernameInput(""); _page.PasswordInput("111111"); _page.Submit(); Assert.Contains("The Email field is required.", _page.UsernameValidator); }
public async Task GetNotificationsByIdsAsync_ReturnNotifications() { //Arrange var id = Guid.NewGuid().ToString(); var type = nameof(RegistrationEmailNotification); var responseGroup = NotificationResponseGroup.Full.ToString(); var notifications = new List <NotificationEntity> { new EmailNotificationEntity() { Id = id, Type = type } }; _repositoryMock.Setup(n => n.GetByIdsAsync(new[] { id }, responseGroup)) .ReturnsAsync(notifications.ToArray()); var criteria = AbstractTypeFactory <NotificationSearchCriteria> .TryCreateInstance(); criteria.Take = 1; criteria.NotificationType = type; _notificationSearchServiceMock.Setup(x => x.SearchNotificationsAsync(criteria)).ReturnsAsync(new NotificationSearchResult()); //TODO //_notificationRegistrar.RegisterNotification<RegistrationEmailNotification>(); var service = GetNotificationService(); var cacheKey = CacheKey.With(service.GetType(), nameof(service.GetByIdsAsync), string.Join("-", new[] { id }), responseGroup); //Act var result = await service.GetByIdsAsync(new[] { id }, responseGroup); //Assert Assert.NotNull(result); Assert.Contains(result, r => r.Id.Equals(id)); Assert.Contains(type, result.Select(x => x.Type)); }
public void IsCollectionContainsEl(int elem) { var list1 = new List <int>() { 1, 2, 3, 4 }; Assert.Contains(elem, list1); }
public static void Contains(string expectedSubstring, string actualString, string message = null) { #if XUNIT XUnitAssert.Contains(expectedSubstring, actualString); #else var comparisonType = (StringComparison)StringComparison.CurrentCulture; var isNotContaining = (actualString == null) || (actualString.IndexOf(expectedSubstring, comparisonType) < 0); NUnitAssert.IsFalse(isNotContaining, message); #endif }
public void Add_WithNameIsEmpty_ReturnUnsuccessful(FriendService sut, Friend newFriend) { newFriend.Name = string.Empty; var result = sut.Add(newFriend); Assert.False(result.Succeeded); Assert.True(result.Reason == ServiceResultFailReason.BusinessValidation); Assert.Contains("Informe o nome do seu amigo", result.Errors); }
public void Add_WithLocationIsNull_ReturnUnsuccessful(FriendService sut, Friend newFriend) { newFriend.Location = null; var result = sut.Add(newFriend); Assert.False(result.Succeeded); Assert.True(result.Reason == ServiceResultFailReason.BusinessValidation); Assert.Contains("Infome a localização do seu amigo.", result.Errors); }
public async Task Create_ValidUser_ReturnsCreatedUser() { UserService userService = new UserService(_fixture.context, _mailOptions); User user = new User(); user.EMail = "*****@*****.**"; await userService.Create(user); Assert.Equal(4, _fixture.context.Users.ToListAsync <User>().Result.Count); Assert.Contains(user, _fixture.context.Users.ToListAsync <User>().Result); }
public void CreateValidItem_ReturnsItems() { MonitoredItemsServices itemsService = new MonitoredItemsServices(_fixture.context); MonitoredItem item = new MonitoredItem { ElementName = "CreatedTest", Url = "www.google.com", Frequency = 5 }; itemsService.Create(Guid.Parse("00000000-0000-0000-0000-000000000001"), item); Assert.Equal(2, _fixture.context.MonitoredItems.ToListAsync <MonitoredItem>().Result.Count); Assert.Contains(item, _fixture.context.MonitoredItems.ToListAsync <MonitoredItem>().Result); }
public void UserMustBeAdded() { //Arrange var user = _databaseFixture.CreateFirstUser(); //Act _databaseFixture.DatabaseAdapter.AddUser(user); var usersFromDB = _databaseFixture.DatabaseAdapter.GetUsers(); //Assert Assert.Contains(usersFromDB, u => u.UserName == user.UserName && u.Id == user.Id); }
private void Then_the_response_is_equal_to_the_scenario_expected_response() { var ExpectedResponse = this.scenario.Response; Assert.Equal(ExpectedResponse.Status, (int)this.response.StatusCode); responseBody = JToken.Parse(this.response.Content.ReadAsStringAsync().Result); Assert.True(JToken.DeepEquals(JToken.Parse(ExpectedResponse.Body), responseBody)); foreach (var key in this.scenario.Response.Headers.Keys) { Assert.True(this.response.Headers.TryGetValues(key, out var ActualValues)); Assert.Contains(this.scenario.Response.Headers[key], ActualValues); } }
public void ListMustReturnAddedProduct() { //Arrange var product = _databaseFixture.GetThirdTestProduct(); //Act _databaseFixture.DatabaseAdapter.AddProduct(product); var list = _databaseFixture.GetProductsList(); Debug.Print($"List of {list.Count} products received"); //Assert Assert.Contains(list, p => p.Name == product.Name && p.Key == product.Key); }
public void SaveKeysCollectionSuccessTest() { #region Test Setup var options = new MemoryCacheOptions(); var cache = new MemoryCache(options); #endregion var mockDefinition = mockDefinitionFake.Generate(); var saveMockDefinitionCommand = new SaveMockDefinitionCommand(mockDefinition, ref TestUtils.databaseLock); var Target = new SaveMockDefinitionHandler(cache, data); Target.Handle(saveMockDefinitionCommand, CancellationToken.None).Result.ToString(); cache.TryGetValue(data.mockIds, out List <string> Actual); Assert.Contains(mockDefinition.Metadata.Title, Actual); }