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 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();
}
}
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 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 static FifthweekUser CreateUser(FifthweekDbContext databaseContext, Random random, UserId userId)
{
var user = UserTests.UniqueEntity(random);
user.Id = userId.Value;
databaseContext.Users.Add(user);
return user;
}
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 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 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 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);
}
}
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 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();
}
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();
}
}
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 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();
}
}
private async Task <FifthweekUser> 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();
}
using (var connection = testDatabase.CreateConnection())
{
var users = await connection.QueryAsync <FifthweekUser>("SELECT * FROM AspNetUsers WHERE Id=@Id", new { Id = UserId.Value });
return(users.Single());
}
}
private async Task CreateDataAsync(
TestDatabaseContext testDatabase,
UserId userId,
Username username,
Email email)
{
var random = new Random();
var user = UserTests.UniqueEntity(random);
user.Id = userId.Value;
user.Email = email.Value;
user.UserName = username.Value;
using (var databaseContext = testDatabase.CreateContext())
{
databaseContext.Users.Add(user);
await databaseContext.SaveChangesAsync();
}
}
private async Task CreateDataAsync(TestDatabaseContext testDatabase)
{
var random = new Random();
var user = UserTests.UniqueEntity(random);
user.Id = RequestorId.Value;
using (var databaseContext = testDatabase.CreateContext())
{
databaseContext.Users.Add(user);
await databaseContext.CreateTestNoteAsync(Guid.NewGuid(), PostId1.Value, random);
await databaseContext.CreateTestNoteAsync(Guid.NewGuid(), PostId2.Value, random);
await databaseContext.CreateTestNoteAsync(Guid.NewGuid(), PostId3.Value, random);
await databaseContext.SaveChangesAsync();
}
}
private async Task CreateDataAsync(TestDatabaseContext testDatabase)
{
using (var databaseContext = testDatabase.CreateContext())
{
var random = new Random();
var creator = UserTests.UniqueEntity(random);
creator.Id = CreatorId1.Value;
var subscription = BlogTests.UniqueEntity(random);
subscription.Creator = creator;
subscription.CreatorId = creator.Id;
var channel1 = ChannelTests.UniqueEntity(random);
channel1.Id = ChannelId1.Value;
channel1.Blog = subscription;
channel1.BlogId = subscription.Id;
var channel2 = ChannelTests.UniqueEntity(random);
channel2.Id = ChannelId2.Value;
channel2.Blog = subscription;
channel2.BlogId = subscription.Id;
var post1 = PostTests.UniqueNote(random);
post1.Id = PostId1.Value;
post1.LiveDate = PostDate1;
post1.Channel = channel1;
post1.ChannelId = channel1.Id;
var post2 = PostTests.UniqueNote(random);
post2.Id = PostId2.Value;
post2.LiveDate = PostDate2;
post2.Channel = channel2;
post2.ChannelId = channel2.Id;
databaseContext.Posts.Add(post1);
databaseContext.Posts.Add(post2);
await databaseContext.SaveChangesAsync();
}
}
private async Task CreateUserAsync(TestDatabaseContext testDatabase, bool emailConfirmed = true)
{
var random = new Random();
var user = UserTests.UniqueEntity(random);
user.Id = this.userId.Value;
user.Email = this.email.Value;
user.EmailConfirmed = emailConfirmed;
using (var databaseContext = testDatabase.CreateContext())
{
databaseContext.Users.Add(user);
await databaseContext.SaveChangesAsync();
}
var profileImageFile = FileTests.UniqueEntity(random);
profileImageFile.Id = this.fileId.Value;
profileImageFile.UserId = user.Id;
var otherFile = FileTests.UniqueEntity(random);
otherFile.Id = this.newFileId.Value;
otherFile.UserId = user.Id;
using (var databaseContext = testDatabase.CreateContext())
{
await databaseContext.Database.Connection.InsertAsync(profileImageFile);
await databaseContext.Database.Connection.InsertAsync(otherFile);
user.ProfileImageFile = profileImageFile;
user.ProfileImageFileId = profileImageFile.Id;
await databaseContext.Database.Connection.UpdateAsync(user, FifthweekUser.Fields.ProfileImageFileId);
}
}
private async Task <IReadOnlyList <UserId> > CreateDataAsync(TestDatabaseContext testDatabase, int creatorChannelsSnapshotCount)
{
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 < creatorChannelsSnapshotCount / 2; i++)
{
var user = UserTests.UniqueEntity(random);
normalUserIds.Add(user.Id);
databaseContext.Users.Add(user);
}
await databaseContext.SaveChangesAsync();
}
using (var connection = testDatabase.CreateConnection())
{
var creatorChannelsSnapshots = new List <SubscriberChannelsSnapshot>();
var creatorChannelsSnapshotItems = new List <SubscriberChannelsSnapshotItem>();
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));
}
creatorChannelsSnapshots.Add(new SubscriberChannelsSnapshot(Guid.NewGuid(), DateTime.UtcNow, Guid.NewGuid()));
creatorChannelsSnapshotItems.Add(new SubscriberChannelsSnapshotItem(creatorChannelsSnapshots.Last().Id, null, Guid.NewGuid(), Guid.NewGuid(), 100, DateTime.UtcNow));
}
for (int i = 0; i < creatorChannelsSnapshotCount - normalUserIds.Count; i++)
{
// Add some deleted users (not in AspNetUsers table).
creatorChannelsSnapshots.Add(new SubscriberChannelsSnapshot(Guid.NewGuid(), DateTime.UtcNow, Guid.NewGuid()));
creatorChannelsSnapshotItems.Add(new SubscriberChannelsSnapshotItem(creatorChannelsSnapshots.Last().Id, null, Guid.NewGuid(), Guid.NewGuid(), 100, DateTime.UtcNow));
}
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));
}
creatorChannelsSnapshots.Add(new SubscriberChannelsSnapshot(Guid.NewGuid(), DateTime.UtcNow, userId));
creatorChannelsSnapshotItems.Add(new SubscriberChannelsSnapshotItem(creatorChannelsSnapshots.Last().Id, null, Guid.NewGuid(), Guid.NewGuid(), 100, DateTime.UtcNow));
}
await connection.InsertAsync(creatorChannelsSnapshots, false);
await connection.InsertAsync(creatorChannelsSnapshotItems, false);
await connection.InsertAsync(userRoles, false);
return(creatorChannelsSnapshots.Where(v => !testUserIds.Contains(v.SubscriberId)).Select(v => new UserId(v.SubscriberId)).ToList());
}
}
private async Task <IEnumerable <IIdentityEquatable> > AddUser(DbConnection connection, Random random, UserId userId, DateTime registrationDate, bool isTestUser, UserId subscriberId = null, ChannelId subscribedToId = null)
{
var users = new List <FifthweekUser>();
var user = UserTests.UniqueEntity(random);
user.Id = userId.Value;
user.RegistrationDate = registrationDate;
users.Add(user);
await connection.InsertAsync(users, false);
var userRoles = new List <FifthweekUserRole>();
userRoles.Add(new FifthweekUserRole(FifthweekRole.CreatorId, user.Id));
if (isTestUser)
{
userRoles.Add(new FifthweekUserRole(FifthweekRole.TestUserId, user.Id));
}
await connection.InsertAsync(userRoles, false);
var blogs = new List <Blog>();
var blog = BlogTests.UniqueEntity(random);
blog.CreatorId = userId.Value;
blogs.Add(blog);
await connection.InsertAsync(blogs);
var channels = new List <Channel>();
var channel = ChannelTests.UniqueEntity(random);
channel.BlogId = blog.Id;
channels.Add(channel);
await connection.InsertAsync(channels);
var queues = new List <Queue>();
var queue = QueueTests.UniqueEntity(random);
queue.BlogId = blog.Id;
queues.Add(queue);
await connection.InsertAsync(queues);
var files = new List <File>();
var file = FileTests.UniqueEntity(random);
file.ChannelId = channel.Id;
file.UserId = userId.Value;
files.Add(file);
await connection.InsertAsync(files);
var posts = new List <Post>();
var post = PostTests.UniqueFileOrImage(random);
post.ChannelId = channel.Id;
post.PreviewImageId = file.Id;
post.ChannelId = channel.Id;
posts.Add(post);
await connection.InsertAsync(posts);
var postFiles = new List <PostFile>();
postFiles.Add(new PostFile(post.Id, file.Id));
await connection.InsertAsync(postFiles);
var channelSubscriptions = new List <ChannelSubscription>();
if (subscriberId != null)
{
channelSubscriptions.Add(new ChannelSubscription(channel.Id, null, subscriberId.Value, null, 100, Now, Now));
await connection.InsertAsync(channelSubscriptions);
}
if (subscribedToId != null)
{
channelSubscriptions.Add(new ChannelSubscription(subscribedToId.Value, null, userId.Value, null, 100, Now, Now));
await connection.InsertAsync(channelSubscriptions);
}
var calculatedAccountBalances = new List <CalculatedAccountBalance>
{
new CalculatedAccountBalance(user.Id, LedgerAccountType.FifthweekCredit, Now),
};
await connection.InsertAsync(calculatedAccountBalances);
var subscriberSnapshots = new List <SubscriberSnapshot>
{
new SubscriberSnapshot(Now, user.Id, "email"),
};
await connection.InsertAsync(subscriberSnapshots);
var subscriberChannelSnapshots = new List <SubscriberChannelsSnapshot>
{
new SubscriberChannelsSnapshot(Guid.NewGuid(), Now, user.Id),
};
await connection.InsertAsync(subscriberChannelSnapshots);
var subscriberChannelSnapshotItems = new List <SubscriberChannelsSnapshotItem>
{
new SubscriberChannelsSnapshotItem(subscriberChannelSnapshots[0].Id, null, channel.Id, user.Id, 100, Now),
};
await connection.InsertAsync(subscriberChannelSnapshotItems);
var creatorChannelSnapshots = new List <CreatorChannelsSnapshot>
{
new CreatorChannelsSnapshot(Guid.NewGuid(), Now, user.Id),
};
await connection.InsertAsync(creatorChannelSnapshots);
var creatorChannelSnapshotItems = new List <CreatorChannelsSnapshotItem>
{
new CreatorChannelsSnapshotItem(creatorChannelSnapshots[0].Id, null, channel.Id, 100),
};
await connection.InsertAsync(creatorChannelSnapshotItems);
var creatorFreeAccessUsersSnapshots = new List <CreatorFreeAccessUsersSnapshot>
{
new CreatorFreeAccessUsersSnapshot(Guid.NewGuid(), Now, user.Id),
};
await connection.InsertAsync(creatorFreeAccessUsersSnapshots);
var creatorFreeAccessUsersSnapshotItems = new List <CreatorFreeAccessUsersSnapshotItem>
{
new CreatorFreeAccessUsersSnapshotItem(creatorFreeAccessUsersSnapshots[0].Id, null, "email"),
};
await connection.InsertAsync(creatorFreeAccessUsersSnapshotItems);
var userPaymentOrigins = new List <UserPaymentOrigin>
{
new UserPaymentOrigin(userId.Value, null, "paymentOriginKey", PaymentOriginKeyType.Stripe, null, null, null, null, PaymentStatus.None),
};
await connection.InsertAsync(userPaymentOrigins);
return(users.Cast <IIdentityEquatable>()
.Concat(userRoles)
.Concat(blogs)
.Concat(channels)
.Concat(queues)
.Concat(files)
.Concat(posts)
.Concat(channelSubscriptions)
.Concat(calculatedAccountBalances)
.Concat(subscriberSnapshots)
.Concat(subscriberChannelSnapshots)
.Concat(subscriberChannelSnapshotItems)
.Concat(creatorChannelSnapshots)
.Concat(creatorChannelSnapshotItems)
.Concat(creatorFreeAccessUsersSnapshots)
.Concat(creatorFreeAccessUsersSnapshotItems)
.Concat(userPaymentOrigins)
.Concat(postFiles));
}
private async Task <IReadOnlyList <UserId> > CreateDataAsync(TestDatabaseContext testDatabase)
{
using (var context = testDatabase.CreateContext())
{
var random = new Random();
var user = UserTests.UniqueEntity(random);
user.Id = UserId1.Value;
user.UserName = Username1.Value;
user.Email = Email1.Value;
user.EmailConfirmed = EmailConfirmed1;
context.Users.Add(user);
await context.SaveChangesAsync();
}
using (var connection = testDatabase.CreateConnection())
{
var snapshots = new List <CalculatedAccountBalance>();
var ledgerRecords = new List <AppendOnlyLedgerRecord>();
for (int i = 0; i < Days; i++)
{
snapshots.Add(new CalculatedAccountBalance(UserId1.Value, LedgerAccountType.FifthweekRevenue, Now.AddDays(i), (i + 1) * 2));
snapshots.Add(new CalculatedAccountBalance(UserId1.Value, LedgerAccountType.FifthweekCredit, Now.AddDays(i), i));
snapshots.Add(new CalculatedAccountBalance(UserId1.Value, LedgerAccountType.Stripe, Now.AddDays(i), i + 0.25m));
snapshots.Add(new CalculatedAccountBalance(UserId1.Value, LedgerAccountType.ReleasedRevenue, Now.AddDays(i), (i + 1) * 4));
ledgerRecords.Add(
new AppendOnlyLedgerRecord(
Guid.NewGuid(),
UserId1.Value,
null,
Now.AddDays(i),
1,
LedgerAccountType.FifthweekRevenue,
LedgerTransactionType.SubscriptionPayment,
Guid.NewGuid(),
null,
null,
null,
null));
snapshots.Add(new CalculatedAccountBalance(UserId2.Value, LedgerAccountType.FifthweekRevenue, Now.AddDays(i), (i + 1) * 3));
snapshots.Add(new CalculatedAccountBalance(UserId2.Value, LedgerAccountType.FifthweekCredit, Now.AddDays(i).AddHours(12), i + 0.5m));
snapshots.Add(new CalculatedAccountBalance(UserId2.Value, LedgerAccountType.Stripe, Now.AddDays(i).AddHours(12), i + 0.75m));
snapshots.Add(new CalculatedAccountBalance(UserId2.Value, LedgerAccountType.ReleasedRevenue, Now.AddDays(i), (i + 1) * 5));
ledgerRecords.Add(
new AppendOnlyLedgerRecord(
Guid.NewGuid(),
UserId2.Value,
null,
Now.AddDays(i),
2,
LedgerAccountType.FifthweekRevenue,
LedgerTransactionType.SubscriptionPayment,
Guid.NewGuid(),
null,
null,
null,
null));
}
snapshots.Add(new CalculatedAccountBalance(UserId3.Value, LedgerAccountType.FifthweekRevenue, Now, 100));
await connection.InsertAsync(snapshots, false);
await connection.InsertAsync(ledgerRecords, false);
return(snapshots.Select(v => new UserId(v.UserId)).ToList());
}
}
private async Task CreateDataAsync(TestDatabaseContext testDatabase)
{
var random = new Random();
using (var databaseContext = testDatabase.CreateContext())
{
// Create some test users which should be ignored.
var testUser = UserTests.UniqueEntity(random);
testUser.Id = TestUserId.Value;
databaseContext.Users.Add(testUser);
// Add one creator to database
var creator = UserTests.UniqueEntity(random);
creator.Id = CreatorId2.Value;
databaseContext.Users.Add(creator);
await databaseContext.SaveChangesAsync();
}
using (var connection = testDatabase.CreateConnection())
{
var subscriberChannelsSnapshots = new List <SubscriberChannelsSnapshot>();
var subscriberChannelsSnapshotItems = new List <SubscriberChannelsSnapshotItem>();
var userRoles = new List <FifthweekUserRole>();
subscriberChannelsSnapshots.Add(new SubscriberChannelsSnapshot(Guid.NewGuid(), Now, SubscriberId.Value));
subscriberChannelsSnapshotItems.Add(new SubscriberChannelsSnapshotItem(subscriberChannelsSnapshots.Last().Id, null, ChannelId1.Value, CreatorId1.Value, 100, Now));
subscriberChannelsSnapshotItems.Add(new SubscriberChannelsSnapshotItem(subscriberChannelsSnapshots.Last().Id, null, ChannelId2.Value, CreatorId1.Value, 100, Now));
subscriberChannelsSnapshots.Add(new SubscriberChannelsSnapshot(Guid.NewGuid(), Now.AddDays(-1), SubscriberId.Value));
subscriberChannelsSnapshotItems.Add(new SubscriberChannelsSnapshotItem(subscriberChannelsSnapshots.Last().Id, null, ChannelId1.Value, CreatorId1.Value, 100, Now));
subscriberChannelsSnapshots.Add(new SubscriberChannelsSnapshot(Guid.NewGuid(), Now.AddDays(1), SubscriberId.Value));
subscriberChannelsSnapshotItems.Add(new SubscriberChannelsSnapshotItem(subscriberChannelsSnapshots.Last().Id, null, ChannelId3.Value, CreatorId2.Value, 100, DateTime.UtcNow));
subscriberChannelsSnapshotItems.Add(new SubscriberChannelsSnapshotItem(subscriberChannelsSnapshots.Last().Id, null, TestUserChannelId.Value, TestUserId.Value, 100, DateTime.UtcNow));
await connection.InsertAsync(subscriberChannelsSnapshots, false);
await connection.InsertAsync(subscriberChannelsSnapshotItems, false);
var creatorChannelsSnapshots = new List <CreatorChannelsSnapshot>();
var creatorChannelsSnapshotItems = new List <CreatorChannelsSnapshotItem>();
creatorChannelsSnapshots.Add(new CreatorChannelsSnapshot(Guid.NewGuid(), DateTime.UtcNow, CreatorId1.Value));
creatorChannelsSnapshotItems.Add(new CreatorChannelsSnapshotItem(creatorChannelsSnapshots.Last().Id, null, ChannelId1.Value, 100));
creatorChannelsSnapshots.Add(new CreatorChannelsSnapshot(Guid.NewGuid(), DateTime.UtcNow, CreatorId1.Value));
creatorChannelsSnapshotItems.Add(new CreatorChannelsSnapshotItem(creatorChannelsSnapshots.Last().Id, null, ChannelId2.Value, 100));
creatorChannelsSnapshots.Add(new CreatorChannelsSnapshot(Guid.NewGuid(), DateTime.UtcNow, CreatorId1.Value));
creatorChannelsSnapshotItems.Add(new CreatorChannelsSnapshotItem(creatorChannelsSnapshots.Last().Id, null, ChannelId2.Value, 100));
userRoles.Add(new FifthweekUserRole(FifthweekRole.CreatorId, CreatorId2.Value));
creatorChannelsSnapshots.Add(new CreatorChannelsSnapshot(Guid.NewGuid(), DateTime.UtcNow, CreatorId2.Value));
creatorChannelsSnapshotItems.Add(new CreatorChannelsSnapshotItem(creatorChannelsSnapshots.Last().Id, null, ChannelId3.Value, 100));
userRoles.Add(new FifthweekUserRole(FifthweekRole.TestUserId, TestUserId.Value));
creatorChannelsSnapshots.Add(new CreatorChannelsSnapshot(Guid.NewGuid(), DateTime.UtcNow, TestUserId.Value));
creatorChannelsSnapshotItems.Add(new CreatorChannelsSnapshotItem(creatorChannelsSnapshots.Last().Id, null, TestUserChannelId.Value, 100));
await connection.InsertAsync(creatorChannelsSnapshots, false);
await connection.InsertAsync(creatorChannelsSnapshotItems, false);
await connection.InsertAsync(userRoles, false);
}
}
private async Task <IReadOnlyList <Post> > CreatePostsAsync(
TestDatabaseContext testDatabase,
UserId userId,
QueueId queueId,
bool liveDateInFuture,
bool scheduledByQueue)
{
using (var databaseContext = testDatabase.CreateContext())
{
var user = UserTests.UniqueEntity(Random);
user.Id = userId.Value;
await databaseContext.Database.Connection.InsertAsync(user);
var file = FileTests.UniqueEntity(Random);
file.Id = FileId.Value;
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 queue = QueueTests.UniqueEntity(Random);
queue.Id = queueId.Value;
queue.BlogId = blog.Id;
await databaseContext.Database.Connection.InsertAsync(queue);
var notes = new List <Post>();
for (var i = 0; i < CollectionTotal; i++)
{
// Notes are not covered by this feature as they do not belong in a collection, but we add them to create a more realistic test state.
var post = PostTests.UniqueNote(Random);
post.ChannelId = channel.Id;
notes.Add(post);
}
var postsInCollection = new List <Post>();
for (var i = 0; i < CollectionTotal; i++)
{
var post = PostTests.UniqueFileOrImage(Random);
post.ChannelId = channel.Id;
post.QueueId = scheduledByQueue ? queueId.Value : (Guid?)null;
post.PreviewImageId = file.Id;
post.LiveDate = Now.AddDays((1 + Random.Next(100)) * (liveDateInFuture ? 1 : -1));
// 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(notes.Concat(postsInCollection));
return(postsInCollection);
}
}
private async Task CreateUser(TestDatabaseContext testDatabase, bool addUser1Roles = true)
{
using (var connection = testDatabase.CreateConnection())
{
var random = new Random();
var user1 = UserTests.UniqueEntity(random);
user1.Id = UserId.Value;
user1.UserName = Username;
user1.PasswordHash = user1.UserName;
var user2 = UserTests.UniqueEntity(random);
user2.Id = Guid.NewGuid();
user2.PasswordHash = user1.UserName;
await connection.InsertAsync(user1);
await connection.InsertAsync(user2);
var role1 = new FifthweekRole(Guid.NewGuid());
role1.Name = "One";
var role2 = new FifthweekRole(Guid.NewGuid());
role2.Name = "Two";
var role3 = new FifthweekRole(Guid.NewGuid());
role3.Name = "Three";
await connection.InsertAsync(role1);
await connection.InsertAsync(role2);
await connection.InsertAsync(role3);
if (addUser1Roles)
{
var userRole1 = new FifthweekUserRole();
userRole1.UserId = user1.Id;
userRole1.RoleId = role1.Id;
var userRole2 = new FifthweekUserRole();
userRole2.UserId = user1.Id;
userRole2.RoleId = role2.Id;
await connection.InsertAsync(userRole1);
await connection.InsertAsync(userRole2);
}
var userRole3 = new FifthweekUserRole();
userRole3.UserId = user2.Id;
userRole3.RoleId = role2.Id;
var userRole4 = new FifthweekUserRole();
userRole4.UserId = user2.Id;
userRole4.RoleId = role3.Id;
await connection.InsertAsync(userRole3);
await connection.InsertAsync(userRole4);
}
}