async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
UserTests.Clear();
var items = await GetFriends();
// var items = new List<UserTest>() { new UserTest() { Id = 1, UserId = "vse ok", Text="ok i will go eat" } };
foreach (var item in items)
{
UserTests.Add(item);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
private async Task <Tuple <UserId, UserId> > CreateDataAsync(TestDatabaseContext testDatabase, int creatorChannelsSnapshotCount)
{
var random = new Random();
var testUserId = Guid.NewGuid();
var normalUserId = Guid.NewGuid();
using (var databaseContext = testDatabase.CreateContext())
{
var testUser = UserTests.UniqueEntity(random);
testUser.Id = testUserId;
databaseContext.Users.Add(testUser);
var normalUser = UserTests.UniqueEntity(random);
normalUser.Id = normalUserId;
databaseContext.Users.Add(normalUser);
await databaseContext.SaveChangesAsync();
}
using (var connection = testDatabase.CreateConnection())
{
var userRoles = new List <FifthweekUserRole>();
userRoles.Add(new FifthweekUserRole(FifthweekRole.CreatorId, normalUserId));
userRoles.Add(new FifthweekUserRole(FifthweekRole.CreatorId, testUserId));
userRoles.Add(new FifthweekUserRole(FifthweekRole.TestUserId, testUserId));
await connection.InsertAsync(userRoles, false);
return(new Tuple <UserId, UserId>(
new UserId(testUserId),
new UserId(normalUserId)));
}
}
private static FifthweekUser CreateUser(FifthweekDbContext databaseContext, Random random, UserId userId)
{
var user = UserTests.UniqueEntity(random);
user.Id = userId.Value;
databaseContext.Users.Add(user);
return user;
}
private async Task CreateDataAsync(TestDatabaseContext testDatabase)
{
using (var databaseContext = testDatabase.CreateContext())
{
var random = new Random();
var creator1 = UserTests.UniqueEntity(random);
creator1.Id = CreatorId1.Value;
var creator2 = UserTests.UniqueEntity(random);
creator2.Id = CreatorId2.Value;
var creator3 = UserTests.UniqueEntity(random);
creator3.Id = CreatorId3.Value;
var override1 = new CreatorPercentageOverride(
CreatorId1.Value,
0.9m,
Now.AddMonths(1));
var override2 = new CreatorPercentageOverride(
CreatorId2.Value,
0.8m,
null);
databaseContext.CreatorPercentageOverrides.Add(override1);
databaseContext.CreatorPercentageOverrides.Add(override2);
databaseContext.Users.Add(creator3);
await databaseContext.SaveChangesAsync();
}
}
public async Task ItShouldCountUsers()
{
await this.DatabaseTestAsync(async testDatabase =>
{
this.InitializeTarget(testDatabase);
var result = await this.target.ExecuteAsync();
Assert.IsTrue(result > 0);
var random = new Random();
var user = UserTests.UniqueEntity(random);
using (var context = testDatabase.CreateContext())
{
context.Users.Add(user);
await context.SaveChangesAsync();
}
await testDatabase.TakeSnapshotAsync();
var result2 = await this.target.ExecuteAsync();
Assert.IsTrue(result == result2 - 1);
return(ExpectedSideEffects.None);
});
}
private async Task CreateUsersAsync(TestDatabaseContext testDatabase)
{
var user1 = UserTests.UniqueEntity(this.random);
user1.Id = UserId1.Value;
user1.Email = UserEmail1.Value;
user1.UserName = Username1.Value;
var user2 = UserTests.UniqueEntity(this.random);
user2.Id = UserId2.Value;
user2.Email = UserEmail2.Value;
user2.UserName = Username2.Value;
using (var databaseContext = testDatabase.CreateContext())
{
databaseContext.Users.Add(user1);
databaseContext.Users.Add(user2);
await databaseContext.SaveChangesAsync();
await databaseContext.CreateTestChannelSubscriptionWithExistingReferences(UserId2.Value, ChannelId1.Value);
await databaseContext.CreateTestChannelSubscriptionWithExistingReferences(UserId2.Value, ChannelId2.Value);
await databaseContext.CreateTestChannelSubscriptionWithExistingReferences(UserId2.Value, ChannelId3.Value);
}
}
private async Task CreateEntitiesAsync(TestDatabaseContext testDatabase)
{
using (var databaseContext = testDatabase.CreateContext())
{
var random = new Random();
var creator = UserTests.UniqueEntity(random);
var blog = BlogTests.UniqueEntity(random);
blog.Creator = creator;
blog.CreatorId = creator.Id;
var orignalChannel = ChannelTests.UniqueEntity(random);
orignalChannel.Id = ChannelId.Value;
orignalChannel.Blog = blog;
orignalChannel.BlogId = blog.Id;
var collection = QueueTests.UniqueEntity(random);
collection.Id = QueueId.Value;
collection.Blog = blog;
collection.BlogId = blog.Id;
databaseContext.Queues.Add(collection);
await databaseContext.SaveChangesAsync();
}
}
private async Task CreateDataAsync(UserId newUserId, TestDatabaseContext testDatabase, bool createOrigin)
{
var random = new Random();
var user = UserTests.UniqueEntity(random);
user.Id = newUserId.Value;
UserPaymentOrigin origin = null;
if (createOrigin)
{
origin = new UserPaymentOrigin(
UserId.Value,
user,
PaymentOriginType,
PaymentOriginKeyType,
CountryCode,
CreditCardPrefix,
IpAddress,
TaxamoTransactionKey,
PaymentStatus);
}
using (var databaseContext = testDatabase.CreateContext())
{
databaseContext.Users.Add(user);
if (createOrigin)
{
databaseContext.UserPaymentOrigins.Add(origin);
}
await databaseContext.SaveChangesAsync();
}
}
private async Task CreateUserAsync(TestDatabaseContext testDatabase)
{
var random = new Random();
var user = UserTests.UniqueEntity(random);
user.Id = CreatorId.Value;
user.UserName = Username.Value;
var file = FileTests.UniqueEntity(random);
file.Id = ProfileFileId.Value;
file.UserId = CreatorId.Value;
using (var databaseContext = testDatabase.CreateContext())
{
databaseContext.Users.Add(user);
await databaseContext.SaveChangesAsync();
}
using (var connection = testDatabase.CreateConnection())
{
await connection.InsertAsync(file);
}
using (var databaseContext = testDatabase.CreateContext())
{
file = await databaseContext.Files.FirstAsync(v => v.Id == ProfileFileId.Value);
user = await databaseContext.Users.FirstAsync(v => v.Id == CreatorId.Value);
user.ProfileImageFile = file;
user.ProfileImageFileId = file.Id;
await databaseContext.SaveChangesAsync();
}
}
private async Task CreateDataAsync(UserId newUserId, TestDatabaseContext testDatabase, bool createOrigin)
{
var random = new Random();
var user = UserTests.UniqueEntity(random);
user.Id = newUserId.Value;
UserPaymentOrigin origin = null;
if (createOrigin)
{
origin = new UserPaymentOrigin(
UserId.Value,
user,
"anotherStripeCustomerId",
PaymentOriginKeyType.Stripe,
"USA",
"999999",
"9.9.9.999",
"anotherKey",
PaymentStatus);
}
using (var databaseContext = testDatabase.CreateContext())
{
databaseContext.Users.Add(user);
if (createOrigin)
{
databaseContext.UserPaymentOrigins.Add(origin);
}
await databaseContext.SaveChangesAsync();
}
}
private decimal GetThisUserTestScore(UserTests userTest)
{
decimal correctAnswers = userTest.Answers.Where(a => a.Answer.Correct).Count();
decimal numOfQuestions = userTest.Test.Questions.Count();
return(Math.Round((correctAnswers / numOfQuestions * 100), 2));
}
public async void StartTesting()
{
userTests = new UserTests(this);
Application.Current.MainWindow.Close();
userTests.Show();
}
private void SaveResultTest(int rightQuestions, int allQuestions, ClaimsPrincipal userClaim, Test test)
{
var email = userClaim.FindFirst("Email");
var user = Database.Users.Get(email.Value);
UserTests userTestsTemp = new UserTests();
userTestsTemp.TestId = test.TestId;
userTestsTemp.UserId = user.UserId;
if (rightQuestions == allQuestions)
{
userTestsTemp.IsFinish = true;
}
else
{
userTestsTemp.IsFinish = false;
}
var userTests = Database.UserTests.Get(userTestsTemp.TestId, userTestsTemp.UserId);
if (userTests == null)
{
Database.UserTests.Create(userTestsTemp);
}
else
{
if (userTests.IsFinish == false && userTestsTemp.IsFinish == true)
{
Database.UserTests.Update(userTestsTemp);
}
}
}
public void Publish_Calls_UtaServiceSaveChanges()
{
//arrange
var categoryName = "Petko";
var someUserTestDto = new UserTestsDTO
{
Category = categoryName,
UserId = correctGuidAsString
};
var fakeUserTest = new UserTests();
mapperMock.Setup(x => x.MapTo <UserTests>(It.IsAny <UserTestsDTO>())).Returns(fakeUserTest);
var fakeUserTests = new List <UserTests>
{
new UserTests
{
UserId = correctGuidAsString,
Id = wrongGuid,
Test = new Test
{
Category = new Category
{
Name = categoryName
}
}
}
}.AsQueryable();
repoUserTestsMock.Setup(x => x.All).Returns(fakeUserTests);
// act
fakeUserTestsService.Publish(someUserTestDto);
// assert
utaServiceMock.Verify(x => x.SaveQuestionAnswers(It.IsAny <UserTestsDTO>()), Times.Once);
}
private async Task CreateEntitiesAsync(TestDatabaseContext testDatabase)
{
using (var databaseContext = testDatabase.CreateContext())
{
var random = new Random();
var creator = UserTests.UniqueEntity(random);
var blog = BlogTests.UniqueEntity(random);
blog.Creator = creator;
blog.CreatorId = creator.Id;
var channel = ChannelTests.UniqueEntity(random);
channel.Id = ChannelId.Value;
channel.Blog = blog;
channel.BlogId = blog.Id;
var queue = QueueTests.UniqueEntity(random);
queue.Id = QueueId.Value;
queue.Blog = blog;
queue.BlogId = blog.Id;
var weeklyReleaseTimes =
new[] { ExistingReleaseA, ExistingReleaseB, ExistingReleaseC }.Select(
_ => new WeeklyReleaseTime(QueueId.Value, (byte)_.Value));
databaseContext.Queues.Add(queue);
await databaseContext.SaveChangesAsync();
await databaseContext.Database.Connection.InsertAsync(weeklyReleaseTimes);
}
}
public void GetResult_GivesCorrectResult()
{
//1 correct answer from 3 questions
//arrange
var userId = correctGuidString;
var categoryname = "Cheficha Cold";
var userTest = new UserTests
{
UserId = userId,
Test = new Test
{
Category = new Category
{
Name = categoryname
},
Questions = new Collection <Question>
{
new Question(),
new Question(),
new Question()
}
}
};
decimal expectedResult = 33.33m;
//(uta => uta.UserTest.UserId == userId && uta.UserTest.Test.Category.Name == category
var all = new List <UserTestAnswers>
{
new UserTestAnswers
{
UserTest = userTest,
Answer = new Answer
{
Correct = true
}
},
new UserTestAnswers
{
UserTest = userTest,
Answer = new Answer
{
Correct = false
}
},
new UserTestAnswers
{
UserTest = userTest,
Answer = new Answer
{
Correct = false
}
}
}.AsQueryable();
repoUserTestAnswersMock.Setup(x => x.All).Returns(all);
//act
var foundResult = fakeUserTestAnswersService.GetResult(userId, categoryname);
// assert
Assert.AreEqual(expectedResult, foundResult);
}
private void CreateUser(Random random, FifthweekDbContext databaseContext, UserId userId)
{
var creator = UserTests.UniqueEntity(random);
creator.Id = userId.Value;
databaseContext.Users.Add(creator);
}
private async Task <IReadOnlyList <UserId> > CreateDataAsync(TestDatabaseContext testDatabase, int normalUserCount)
{
var random = new Random();
var testUserIds = new List <Guid>();
var normalUserIds = new List <Guid>();
using (var databaseContext = testDatabase.CreateContext())
{
// Create some test users which should be ignored.
for (int i = 0; i < 3; i++)
{
var user = UserTests.UniqueEntity(random);
testUserIds.Add(user.Id);
databaseContext.Users.Add(user);
}
// Create some normal users which shouldn't be ignored.
for (int i = 0; i < normalUserCount; i++)
{
var user = UserTests.UniqueEntity(random);
normalUserIds.Add(user.Id);
databaseContext.Users.Add(user);
}
await databaseContext.SaveChangesAsync();
}
using (var connection = testDatabase.CreateConnection())
{
var userRoles = new List <FifthweekUserRole>();
foreach (var userId in normalUserIds)
{
// Add some normal users to creator roles.
if (random.NextDouble() > 0.5)
{
userRoles.Add(new FifthweekUserRole(FifthweekRole.CreatorId, userId));
}
}
foreach (var userId in testUserIds)
{
// Add some test users.
userRoles.Add(new FifthweekUserRole(FifthweekRole.TestUserId, userId));
if (random.NextDouble() > 0.5)
{
userRoles.Add(new FifthweekUserRole(FifthweekRole.CreatorId, userId));
}
}
await connection.InsertAsync(userRoles, false);
return(normalUserIds.Select(v => new UserId(v)).ToList());
}
}
private async Task CreateUserAsync(FifthweekDbContext databaseContext, UserId userId)
{
var user = UserTests.UniqueEntity(this.random);
user.Id = userId.Value;
user.Email = userId.Value + "@test.com";
databaseContext.Users.Add(user);
await databaseContext.SaveChangesAsync();
}
public void SaveTest_Calls_RepoAdd()
{
//arrange
var someUserTestDto = new UserTestsDTO();
var fakeUserTest = new UserTests();
mapperMock.Setup(x => x.MapTo <UserTests>(It.IsAny <UserTestsDTO>())).Returns(fakeUserTest);
// act
fakeUserTestsService.SaveTest(someUserTestDto);
// assert
repoUserTestsMock.Verify(x => x.Add(It.IsAny <UserTests>()), Times.Once);
}
public void SaveTest_Calls_GetDateTimeNow()
{
//arrange
var someUserTestDto = new UserTestsDTO();
var fakeUserTest = new UserTests();
mapperMock.Setup(x => x.MapTo <UserTests>(It.IsAny <UserTestsDTO>())).Returns(fakeUserTest);
// act
fakeUserTestsService.SaveTest(someUserTestDto);
// assert
dateTimeProviderMock.Verify(x => x.GetDateTimeNow(), Times.Once);
}
public void GetUserTestId_ThrowWhen_CategoryNameIsNull()
{
//arrange
var someUserTestDto = new UserTestsDTO
{
UserId = correctGuidAsString
};
var fakeUserTest = new UserTests();
mapperMock.Setup(x => x.MapTo <UserTests>(It.IsAny <UserTestsDTO>())).Returns(fakeUserTest);
// act & assert
Assert.ThrowsException <ArgumentNullException>(() => fakeUserTestsService.Publish(someUserTestDto));
}
private async Task CreateUserAsync(TestDatabaseContext testDatabase)
{
var random = new Random();
var user = UserTests.UniqueEntity(random);
user.Id = UserId.Value;
using (var databaseContext = testDatabase.CreateContext())
{
databaseContext.Users.Add(user);
await databaseContext.SaveChangesAsync();
}
}
private async Task CreateUserAsync(TestDatabaseContext testDatabase, string username, string email)
{
var random = new Random();
var user = UserTests.UniqueEntity(random);
user.Email = email;
user.UserName = username;
using (var databaseContext = testDatabase.CreateContext())
{
databaseContext.Users.Add(user);
await databaseContext.SaveChangesAsync();
}
}
private async Task CreateUserAsync(TestDatabaseContext testDatabase)
{
var user = UserTests.UniqueEntity(this.random);
user.Id = UserId.Value;
user.Email = UserEmail.Value;
user.UserName = Username.Value;
using (var databaseContext = testDatabase.CreateContext())
{
databaseContext.Users.Add(user);
await databaseContext.SaveChangesAsync();
}
}
public void GetUserTestId_ThrowWhen_UserIdNull()
{
//arrange
var categoryName = "Petko";
var someUserTestDto = new UserTestsDTO
{
Category = categoryName,
};
var fakeUserTest = new UserTests();
mapperMock.Setup(x => x.MapTo <UserTests>(It.IsAny <UserTestsDTO>())).Returns(fakeUserTest);
// act & assert
Assert.ThrowsException <ArgumentNullException>(() => fakeUserTestsService.Publish(someUserTestDto));
}
private async Task CreateUserAsync(TestDatabaseContext testDatabase)
{
var random = new Random();
var user = UserTests.UniqueEntity(random);
user.Id = UserId.Value;
user.LastSignInDate = TimeStamp.AddSeconds(-360);
user.LastAccessTokenDate = TimeStamp.AddSeconds(-180);
using (var databaseContext = testDatabase.CreateContext())
{
databaseContext.Users.Add(user);
await databaseContext.SaveChangesAsync();
}
}
private async Task <IReadOnlyList <Post> > CreatePostsAsync(
TestDatabaseContext testDatabase,
QueueId queueId,
IReadOnlyList <DateTime> liveDates,
bool scheduledByQueue)
{
using (var databaseContext = testDatabase.CreateContext())
{
var user = UserTests.UniqueEntity(Random);
await databaseContext.Database.Connection.InsertAsync(user);
var file = FileTests.UniqueEntity(Random);
file.UserId = user.Id;
await databaseContext.Database.Connection.InsertAsync(file);
var blog = BlogTests.UniqueEntity(Random);
blog.CreatorId = user.Id;
await databaseContext.Database.Connection.InsertAsync(blog);
var channel = ChannelTests.UniqueEntity(Random);
channel.BlogId = blog.Id;
await databaseContext.Database.Connection.InsertAsync(channel);
var collection = QueueTests.UniqueEntity(Random);
collection.Id = queueId.Value;
collection.BlogId = blog.Id;
await databaseContext.Database.Connection.InsertAsync(collection);
var postsInCollection = new List <Post>();
foreach (var liveDate in liveDates)
{
var post = PostTests.UniqueNote(Random);
post.ChannelId = channel.Id;
post.QueueId = scheduledByQueue ? queueId.Value : (Guid?)null;
post.LiveDate = liveDate;
// Clip dates as we will be comparing from these entities.
post.LiveDate = new SqlDateTime(post.LiveDate).Value;
post.CreationDate = new SqlDateTime(post.CreationDate).Value;
postsInCollection.Add(post);
}
await databaseContext.Database.Connection.InsertAsync(postsInCollection);
return(postsInCollection);
}
}
private async void DeleteFriend(object friendObject)
{
Answer friend = friendObject as Answer;
if (friend != null)
{
IsBusy = true;
UserTest deletedFriend = await friendsService.Delete(friend.Id);
if (deletedFriend != null)
{
UserTests.Remove(deletedFriend);
}
IsBusy = false;
}
Back();
}
private async Task CreateFileAsync(UserId newUserId, FileId newFileId, TestDatabaseContext testDatabase)
{
var random = new Random();
var user = UserTests.UniqueEntity(random);
user.Id = newUserId.Value;
var file = FileTests.UniqueEntity(random);
file.Id = newFileId.Value;
file.UserId = newUserId.Value;
using (var databaseContext = testDatabase.CreateContext())
{
databaseContext.Users.Add(user);
databaseContext.Files.Add(file);
await databaseContext.SaveChangesAsync();
}
}
