public async Task FindParticipantMatchesAsync_ShouldBeEquivalentToParticipantMatchList(Game game, ChallengeState state)
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(89568322, game, state);
var challenge = challengeFaker.FakeChallenge();
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var challengeRepository = new ChallengeRepository(context);
challengeRepository.Create(challenge);
await challengeRepository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var matchQuery = new MatchQuery(context);
foreach (var participant in challenge.Participants)
{
//Act
var matches = await matchQuery.FetchParticipantMatchesAsync(ParticipantId.FromGuid(participant.Id));
//Arrange
matches.Should().BeEquivalentTo(participant.Matches.ToList());
}
}
}
public async Task FindMatchAsync_ShouldBeEquivalentToMatch(Game game, ChallengeState state)
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(83459632, game, state);
var challenge = challengeFaker.FakeChallenge();
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var challengeRepository = new ChallengeRepository(context);
challengeRepository.Create(challenge);
await challengeRepository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var matchQuery = new MatchQuery(context);
foreach (var match in challenge.Participants.SelectMany(participant => participant.Matches).ToList())
{
//Act
var matchAsync = await matchQuery.FindMatchAsync(MatchId.FromGuid(match.Id));
//Arrange
matchAsync.Should().BeEquivalentTo(match);
}
}
}
public async Task InvalidPassword_ShouldReturnInvalidPasswordError()
{
//Arrange
IRepository repository = new InMemoryDbContextFactory().GetDbContext();
var myConfiguration = new Dictionary <string, string>
{
{ "Secret", "SUPERSECRETTESTSTRING" },
};
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(myConfiguration)
.Build();
var authorizationProvider = new AuthorizationProvider(repository, configuration);
var userInDb = new User(new RegisterUserDto
{
Email = "*****@*****.**",
Name = "test",
Password = "******"
});
await userInDb.Register(repository);
var userLogin = new LoginUserDto
{
Email = "*****@*****.**",
Password = "******"
};
//Act
var result = await authorizationProvider.Authenticate(userLogin);
//Assert
Assert.AreEqual(UserErrorMessages.InvalidPassword, result.ErrorMessage);
}
private static CategoryQueryHandler CreateHandler()
{
var ctx = new InMemoryDbContextFactory().CreateContext();
var projectorMock = ProjectorMock();
return(new CategoryQueryHandler(projectorMock.Object, ctx));
}
public async Task FindChallengeAsync_FromRepository_ShouldNotBeNull()
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(1, Game.LeagueOfLegends);
var fakeChallenge = challengeFaker.FakeChallenge();
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var repository = new ChallengeRepository(context);
repository.Create(fakeChallenge);
await repository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var repository = new ChallengeRepository(context);
//Act
var challenge = await repository.FindChallengeOrNullAsync(fakeChallenge.Id);
//Assert
challenge.Should().NotBeNull();
}
}
public async Task FetchChallengesAsync_ShouldHaveCount(Game game, ChallengeState state)
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(84936374, game);
var fakeChallenges = challengeFaker.FakeChallenges(4);
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var challengeRepository = new ChallengeRepository(context);
challengeRepository.Create(fakeChallenges);
await challengeRepository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var challengeQuery = new ChallengeQuery(context);
//Act
var challenges = await challengeQuery.FetchChallengesAsync(game, state);
//Assert
challenges.Should().HaveCount(fakeChallenges.Count(challenge => challenge.Game == game && challenge.Timeline == state));
}
}
public AuthenticationTests()
{
var dbContextFactory = new InMemoryDbContextFactory();
userContext = new TestUserContext();
authenticationService = new AuthenticationService(userContext, dbContextFactory);
}
public async Task FetchUserChallengeHistoryAsync_WhenChallengeQuery_ShouldBeChallenge(Game game, ChallengeState state)
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(84566374, game, state);
var challenge = challengeFaker.FakeChallenge();
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var challengeRepository = new ChallengeRepository(context);
challengeRepository.Create(challenge);
await challengeRepository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var challengeQuery = new ChallengeQuery(context);
//Act
var challenges = await challengeQuery.FetchUserChallengeHistoryAsync(challenge.Participants.First().UserId, game, state);
//Assert
challenges.Single().Should().Be(challenge);
}
}
public void Create_Ticket_Will_Be_Success(Ticket ticketOk1, Ticket ticketOk2, Ticket ticketOk3)
{
using (var context = new InMemoryDbContextFactory().GetDbContext())
{
var repositoryTicket = new Repository <Ticket, int>(context);
var repositoryPriority = new Repository <Priority, int>(context);
var repositoryStatus = new Repository <Status, int>(context);
var repositoryTicketType = new Repository <TicketType, int>(context);
var serviceTicket = new TicketService(repositoryTicket);
var serviceParameters = new ParametersService(repositoryPriority, repositoryStatus, repositoryTicketType);
using (var controller = new TicketController(serviceTicket, serviceParameters))
{
int cantidad = 1;
foreach (var ticket in new List <Ticket> {
ticketOk1, ticketOk2, ticketOk3
})
{
var result = controller.Create(ticket);
var viewResult = Assert.IsType <RedirectToActionResult>(result.Result);
Assert.Equal(cantidad, serviceTicket.GetAll().Result.Count);
cantidad++;
}
}
}
}
public void BaseSaveAndUpdateTest()
{
Formula formual = Formula.Create("F1", "AC20-120-水下", null);
formual.AddFormulaItem(FormulaItem.Create(string.Empty, "B1", "N1", 10));
formual.AddFormulaItem(FormulaItem.Create(string.Empty, "B2", "N2", 20));
formual.AddFormulaItem(FormulaItem.Create(string.Empty, "B3", "N3", 30));
Assert.Equal(3, formual.FormulaItemCount);
DbContextOptions <FormulaContext> options = InMemoryDbContextFactory.CreateOptions <FormulaContext>("Formula-Base");
using (FormulaContext content = new FormulaContext(options))
{
var obj = content.Formulas.Find("F1");
Assert.Null(obj);
content.Formulas.Add(formual);
content.SaveChanges();
var objRead = content.Formulas.Find("F1");
Assert.NotNull(objRead);
Assert.Equal(3, objRead.FormulaItemCount);
}
}
public async Task FetchData_UpdatedLastModified_FetchesDataTwice()
{
var serviceMockFactory = new ServiceMockFactory();
var dataService = serviceMockFactory.GetDataService();
var mapper = serviceMockFactory.GetMapper();
var context = new InMemoryDbContextFactory().GetArticleDbContext();
var jobService = new JobsService(dataService, context, mapper);
await jobService.FetchHeaders();
await jobService.FetchData();
var updatedDataService = serviceMockFactory.
GetDataService("Sun, 29 Mar 2020 14:23:25 GMT",
TestContext.CurrentContext.TestDirectory + "\\Data\\UpdatedTestData.xml");
var updatedJobService = new JobsService(updatedDataService, context, mapper);
await updatedJobService.FetchHeaders();
await updatedJobService.FetchData();
context.SdnEntities.Count().Should().NotBe(0);
context.SdnEntities.FirstOrDefault().SdnType.Should().Be("NewType");
}
public async Task FindChallengeParticipantsAsync_ShouldBeEquivalentToParticipantList(Game game, ChallengeState state)
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(68545632, game, state);
var challenge = challengeFaker.FakeChallenge();
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var challengeRepository = new ChallengeRepository(context);
challengeRepository.Create(challenge);
await challengeRepository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var participantQuery = new ParticipantQuery(context);
//Act
var participants = await participantQuery.FetchChallengeParticipantsAsync(challenge.Id);
//Assert
participants.Should().BeEquivalentTo(challenge.Participants.ToList());
}
}
public void InstantiatesController()
{
var context = InMemoryDbContextFactory.GetDbContext();
var controller = new ScreeningController(context);
Assert.NotNull(controller);
}
public async Task GivenAccountRepository_WhenCallCreate_ShouldSuccess()
{
using (var context = await InMemoryDbContextFactory.CreateUserContext())
{
// assign
var testData = (memebrId : 0, accountId : 0, memebrAccountId : 1);
var member = MemberDataBuilder.CreateMember(testData.memebrId, new List <MemberAccount>(), null, null);
await context.Members.AddAsync(member);
await context.SaveChangesAsync();
var memberAccount = MemberDataBuilder.CreateMemberAccount(testData.memebrAccountId, testData.accountId, testData.memebrId);
var account = AccountDataBuilder.CreateAccount(testData.accountId, new List <MemberAccount> {
memberAccount
});
// act
var repo = new AccountRepository(context);
await repo.Create(account);
await context.SaveChangesAsync();
// assert
account.Id.ShouldBeGreaterThan(0);
}
}
private static TagSaveCommandHandler CreateHandler()
{
var ctx = new InMemoryDbContextFactory().CreateContext();
var mapperMock = new Mock <Mapping.IMapper>();
return(new TagSaveCommandHandler(mapperMock.Object, ctx));
}
public async void AddsScreening()
{
var context = InMemoryDbContextFactory.GetDbContext();
context.Movies.Add(new Movie {
MovieId = 1
});
context.ScreeningRooms.Add(new ScreeningRoom {
ScreeningRoomId = 1
});
await context.SaveChangesAsync();
var controller = new ScreeningController(context);
var time = DateTime.Now;
var Screening = new Screening {
DateTime = time, ScreeningRoomId = 1, MovieId = 1
};
var response = await controller.AddScreening(Screening);
Assert.IsType <OkObjectResult>(response.Result);
var okRes = (OkObjectResult)response.Result;
Assert.Equal(time, ((Screening)okRes.Value).DateTime);
}
public async Task FindChallengeAsync_ShouldBeChallenge(Game game, ChallengeState state)
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(84568994, game, state);
var challenge = challengeFaker.FakeChallenge();
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var challengeRepository = new ChallengeRepository(context);
challengeRepository.Create(challenge);
await challengeRepository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var challengeQuery = new ChallengeQuery(context);
//Act
var challengeAsync = await challengeQuery.FindChallengeAsync(challenge.Id);
//Assert
challengeAsync.Should().Be(challenge);
}
}
public void InitializeIntegrationTest()
{
var servicesToReplace = new List <(Type, object)>();
var configDict = new Dictionary <string, string>
{
{ "IdentityConfiguration:JwtSecret", "2346sedrfgsrahyjrtyserASD@" },
{ "IdentityConfiguration:ExpirationInSeconds", "3600" },
{ "WolkConfiguration:UploadsPath", UploadsRootPath }
};
BeforeConfigure(configDict);
var config = new ConfigurationBuilder()
.AddInMemoryCollection(configDict)
.Build();
var startup = new Startup(config);
InitializeDefaultDateTime();
var wolkDbContext = InMemoryDbContextFactory.Create();
servicesToReplace.Add((typeof(IWolkDbContext), wolkDbContext));
servicesToReplace.Add((typeof(IFileService), MockFileService));
servicesToReplace.Add((typeof(IDateTime), MockDateTime.Object));
var mockEnvironment = new Mock <IWebHostEnvironment>();
mockEnvironment
.Setup(m => m.EnvironmentName)
.Returns("Production");
TestServer = new TestServer(new WebHostBuilder()
.ConfigureServices(services => ConfigureServices(startup, services, servicesToReplace))
.Configure(app => Startup.ConfigureStatic(app, mockEnvironment.Object, false, false)));
HttpClient = TestServer.CreateClient();
}
public async Task StockSymbolUpdaterCommandHandlerTest()
{
using var contextFactory = new InMemoryDbContextFactory();
var mockResult = GetMockResult();
using (var db = contextFactory.CreateDbContext())
{
// Load the database with one stock.
var stock = mockResult.NasdaqSymbols.First();
db.Stocks.Add(new StockEntity()
{
Symbol = stock.Symbol, Name = stock.SecurityName
});
await db.SaveChangesAsync();
}
var mediatorMock = new Mock <IMediator>();
mediatorMock.Setup(x => x.Send(It.IsAny <GetAllSymbolsNasdaq.Query>(), It.IsAny <CancellationToken>())).ReturnsAsync(mockResult);
var command = new StockSymbolUpdater.Command();
var handler = new StockSymbolUpdater.Handler(mediatorMock.Object, contextFactory);
await handler.Handle(command, CancellationToken.None);
List <StockEntity> dbStocks;
using (var db = contextFactory.CreateDbContext())
{
dbStocks = await db.Stocks.ToListAsync();
}
Assert.Equal(6, dbStocks.Count);
}
public async Task FindParticipantAsync_EquivalentToParticipant(Game game, ChallengeState state)
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(48956632, game, state);
var challenge = challengeFaker.FakeChallenge();
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var challengeRepository = new ChallengeRepository(context);
challengeRepository.Create(challenge);
await challengeRepository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var participantQuery = new ParticipantQuery(context);
foreach (var participant in challenge.Participants)
{
//Act
var participantAsync = await participantQuery.FindParticipantAsync(ParticipantId.FromGuid(participant.Id));
//Assert
participantAsync.Should().BeEquivalentTo(participant);
}
}
}
public async Task FetchData_GivenPreviousLastModified_DataShouldNotBeUpdated()
{
var serviceMockFactory = new ServiceMockFactory();
var dataService = serviceMockFactory.GetDataService();
var mapper = serviceMockFactory.GetMapper();
var context = new InMemoryDbContextFactory().GetArticleDbContext();
var jobService = new JobsService(dataService, context, mapper);
await jobService.FetchHeaders();
await jobService.FetchData();
var updatedDataService = serviceMockFactory.
GetDataService("Sun, 29 Mar 2020 14:23:25 GMT",
TestContext.CurrentContext.TestDirectory + "\\Data\\UpdatedTestData.xml");
var updatedJobService = new JobsService(updatedDataService, context, mapper);
await updatedJobService.FetchHeaders();
await updatedJobService.FetchData();
var dataServiceWithNewEntry = serviceMockFactory.
GetDataService("Sat, 28 Mar 2020 12:23:25 GMT",
TestContext.CurrentContext.TestDirectory + "\\Data\\UpdatedTestDataWithNewEntry.xml");
updatedJobService = new JobsService(dataServiceWithNewEntry, context, mapper);
await updatedJobService.FetchHeaders();
await updatedJobService.FetchData();
context.SdnEntities.Count().Should().NotBe(0);
context.SdnEntities.Select(s => s.LastName).Should().NotContain("Aml-Analytics");
}
public CommentRepositoryTest(ITestOutputHelper output)
{
ITeamChatDbContextFactory factory = new InMemoryDbContextFactory();
this._userRepository = new UserRepository(factory);
this._commentRepository = new CommentRepository(factory);
this._postRepository = new PostRepository(factory);
}
public FavoriteEventsTests()
{
var dbContextFactory = new InMemoryDbContextFactory();
context = new TestUserContext();
events = new FavoriteEventsService(context, dbContextFactory);
auth = new AuthenticationService(context, dbContextFactory);
}
public async Task GetAlertDefinitionAsync_InvalidAlertDefinitionId_NotFoundException()
{
// Arrange
var context = await InMemoryDbContextFactory.CreateDatabaseContextAsync();
var repository = CreateRepository(context, CreateMapper());
// Act & Assert
await Assert.ThrowsAsync <NotFoundException>(async() => await repository.GetAlertDefinitionAsync(Guid.NewGuid()));
}
public async Task GetStockAsync_StockIdDoesNotExist_NotFoundException()
{
// Arrange
var context = await InMemoryDbContextFactory.CreateDatabaseContextAsync();
var repository = CreateRepository(context);
// Act & Assert
await Assert.ThrowsAsync <NotFoundException>(async() => await repository.GetStockAsync(Guid.NewGuid()));
}
public QueueTypeControllerTest(CustomWebApplicationFactory <Startup> factory)
{
_factory = factory;
_context = new InMemoryDbContextFactory().GetPriorityQueueDbContext();
_context.QueueType.RemoveRange(_context.QueueType);
_queueTypeRepository = new QueueTypeRepository(_context);
_queueTypeService = new QueueTypeService(_queueTypeRepository);
_controller = new QueueTypeController(_queueTypeService);
_client = factory.CreateClient(new WebApplicationFactoryClientOptions());
}
public FavoriteUsersTests()
{
var dbContextFactory = new InMemoryDbContextFactory();
firstContext = new TestUserContext();
firstFavoriteUsers = new FavoriteUsersService(firstContext, dbContextFactory);
firstAuth = new AuthenticationService(firstContext, dbContextFactory);
secondContext = new TestUserContext();
secondFavoriteUsers = new FavoriteUsersService(secondContext, dbContextFactory);
secondAuth = new AuthenticationService(secondContext, dbContextFactory);
}
public async Task TestSetup()
{
var serviceMockFactory = new ServiceMockFactory();
var dataService = serviceMockFactory.GetDataService();
var mapper = serviceMockFactory.GetMapper();
var context = new InMemoryDbContextFactory().GetArticleDbContext();
var jobService = new JobsService(dataService, context, mapper);
await jobService.FetchData();
context.SdnEntities.Count().Should().NotBe(0);
}
public GroupsTests()
{
var dbContextFactory = new InMemoryDbContextFactory();
firstContext = new TestUserContext();
firstGroups = new GroupsService(firstContext, dbContextFactory);
firstAuth = new AuthenticationService(firstContext, dbContextFactory);
secondContext = new TestUserContext();
secondGroups = new GroupsService(secondContext, dbContextFactory);
secondAuth = new AuthenticationService(secondContext, dbContextFactory);
}
public async Task FindStocksAsync_NoMatch_EmptyListReturned()
{
// Arrange
var context = await InMemoryDbContextFactory.CreateDatabaseContextAsync();
var repository = CreateRepository(context);
// Act
var stocks = await repository.FindStocksAsync("XYZ", CancellationToken.None);
// Assert
stocks.Should().BeEmpty();
}
