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