private static MergedSnapshot CreateSnapshot(DateTime subscriptionStartDate, DateTime timestamp, bool channelExists, bool isSubscribed, DateTime?innerTimestamp = null)
{
var creatorChannels = new List <CreatorChannelsSnapshotItem> {
new CreatorChannelsSnapshotItem(ChannelId2, 100)
};
if (channelExists)
{
creatorChannels.Add(new CreatorChannelsSnapshotItem(ChannelId1, 100));
}
var subscriberChannels = new List <SubscriberChannelsSnapshotItem> {
new SubscriberChannelsSnapshotItem(ChannelId2, 100, subscriptionStartDate)
};
if (isSubscribed)
{
subscriberChannels.Add(new SubscriberChannelsSnapshotItem(ChannelId1, 100, subscriptionStartDate));
}
return(new MergedSnapshot(
timestamp,
new CreatorChannelsSnapshot(innerTimestamp ?? timestamp, CreatorId1, creatorChannels),
CreatorFreeAccessUsersSnapshot.Default(innerTimestamp ?? timestamp, CreatorId1),
new SubscriberChannelsSnapshot(innerTimestamp ?? timestamp, SubscriberId1, subscriberChannels),
SubscriberSnapshot.Default(innerTimestamp ?? timestamp, SubscriberId1),
CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(innerTimestamp ?? timestamp, SubscriberId1)));
}
public async Task WhenCreatorDoesNotExist_ShouldCreateEmptySnapshot()
{
await this.DatabaseTestAsync(async testDatabase =>
{
this.guidCreator.Setup(v => v.CreateSqlSequential()).Returns(SnapshotId);
this.timestampCreator.Setup(v => v.Create()).Returns(Now);
this.target = new CreateCreatorFreeAccessUsersSnapshotDbStatement(
this.guidCreator.Object,
this.timestampCreator.Object,
testDatabase);
await this.CreateDataAsync(testDatabase);
await testDatabase.TakeSnapshotAsync();
var creatorId = UserId.Random();
await this.target.ExecuteAsync(creatorId);
var expectedCreatorFreeAccessUsersSnapshot = new CreatorFreeAccessUsersSnapshot(SnapshotId, Now, creatorId.Value);
return(new ExpectedSideEffects
{
Inserts = new List <IIdentityEquatable>
{
expectedCreatorFreeAccessUsersSnapshot,
}
});
});
}
public async Task WhenCreatorExists_ShouldCreateSnapshot()
{
await this.DatabaseTestAsync(async testDatabase =>
{
this.guidCreator.Setup(v => v.CreateSqlSequential()).Returns(SnapshotId);
this.timestampCreator.Setup(v => v.Create()).Returns(Now);
this.target = new CreateCreatorFreeAccessUsersSnapshotDbStatement(
this.guidCreator.Object,
this.timestampCreator.Object,
testDatabase);
await this.CreateDataAsync(testDatabase);
await testDatabase.TakeSnapshotAsync();
await this.target.ExecuteAsync(CreatorId);
var expectedCreatorFreeAccessUsersSnapshot = new CreatorFreeAccessUsersSnapshot(SnapshotId, Now, CreatorId.Value);
var expectedCreatorFreeAccessUsersItem1 = new CreatorFreeAccessUsersSnapshotItem(SnapshotId, null, Email1);
var expectedCreatorFreeAccessUsersItem2 = new CreatorFreeAccessUsersSnapshotItem(SnapshotId, null, Email2);
return(new ExpectedSideEffects
{
Inserts = new List <IIdentityEquatable>
{
expectedCreatorFreeAccessUsersSnapshot,
expectedCreatorFreeAccessUsersItem1,
expectedCreatorFreeAccessUsersItem2,
}
});
});
}
public void WhenFirstSnapshotAfterStartTime_ShouldReturnSnapshotAtStartTimeAndSnapshotAtSnapshotTime()
{
var creatorSnapshot = new CreatorChannelsSnapshot(Now.AddDays(1), CreatorId1, new List <CreatorChannelsSnapshotItem> {
new CreatorChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100)
});
var expectedResult = new List <MergedSnapshot>
{
new MergedSnapshot(
Now,
CreatorChannelsSnapshot.Default(Now, CreatorId1),
CreatorFreeAccessUsersSnapshot.Default(Now, CreatorId1),
SubscriberChannelsSnapshot.Default(Now, SubscriberId1),
SubscriberSnapshot.Default(Now, SubscriberId1),
CalculatedAccountBalanceSnapshot.Default(Now, SubscriberId1, LedgerAccountType.FifthweekCredit)),
new MergedSnapshot(
Now.AddDays(1),
creatorSnapshot,
CreatorFreeAccessUsersSnapshot.Default(Now, CreatorId1),
SubscriberChannelsSnapshot.Default(Now, SubscriberId1),
SubscriberSnapshot.Default(Now, SubscriberId1),
CalculatedAccountBalanceSnapshot.Default(Now, SubscriberId1, LedgerAccountType.FifthweekCredit)),
};
var result = this.target.Execute(SubscriberId1, CreatorId1, Now, new List <ISnapshot> {
creatorSnapshot
});
CollectionAssert.AreEqual(expectedResult, result.ToList());
}
public void WhenOneSnapshot_ItShouldReturnCostPeriod()
{
var defaultCreatorChannelsSnapshot = CreatorChannelsSnapshot.Default(Now, CreatorId1);
var defaultCreatorGuestListSnapshot = CreatorFreeAccessUsersSnapshot.Default(Now, CreatorId1);
var defaultSubscriberChannelsSnapshot = SubscriberChannelsSnapshot.Default(Now, SubscriberId1);
var defaultSubscriberSnapshot = SubscriberSnapshot.Default(Now, SubscriberId1);
var defaultCalculatedAccountBalanceSnapshot = CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(Now, UserId.Random());
var mergedSnapshots = new List <MergedSnapshot>
{
new MergedSnapshot(
Now.AddHours(5),
defaultCreatorChannelsSnapshot,
defaultCreatorGuestListSnapshot,
defaultSubscriberChannelsSnapshot,
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
};
this.costCalculator.Setup(v => v.Execute(It.IsAny <MergedSnapshot>(), creatorPosts))
.Returns <MergedSnapshot, IReadOnlyList <CreatorPost> >((s, p) => (int)Math.Round((s.Timestamp - Now).TotalHours + 10));
var expectedOutput = new List <CostPeriod>
{
new CostPeriod(Now.AddHours(5), Now.AddHours(10), 15),
};
var result = this.target.Execute(Now, Now.AddHours(10), mergedSnapshots, creatorPosts);
CollectionAssert.AreEqual(expectedOutput, result.ToList());
}
public IReadOnlyList <MergedSnapshot> Execute(
UserId subscriberId,
UserId creatorId,
DateTime startTimeInclusive,
IReadOnlyList <ISnapshot> snapshots)
{
if (snapshots.Count == 0)
{
return(new List <MergedSnapshot>());
}
DateTime initialTimestamp = startTimeInclusive;
var firstTimestamp = snapshots[0].Timestamp;
if (firstTimestamp < startTimeInclusive)
{
initialTimestamp = firstTimestamp;
}
var creatorChannels = CreatorChannelsSnapshot.Default(initialTimestamp, creatorId);
var creatorFreeAccessUsers = CreatorFreeAccessUsersSnapshot.Default(initialTimestamp, creatorId);
var subscriberChannels = SubscriberChannelsSnapshot.Default(initialTimestamp, subscriberId);
var subscriber = SubscriberSnapshot.Default(initialTimestamp, subscriberId);
var calculatedAccountBalance = CalculatedAccountBalanceSnapshot.Default(initialTimestamp, subscriberId, LedgerAccountType.FifthweekCredit);
var mergedSnapshots = new List <MergedSnapshot>();
if (firstTimestamp > initialTimestamp)
{
mergedSnapshots.Add(new MergedSnapshot(creatorChannels, creatorFreeAccessUsers, subscriberChannels, subscriber, calculatedAccountBalance));
}
foreach (var snapshot in snapshots)
{
var assigned = this.TryAssign(snapshot, ref creatorChannels) ||
this.TryAssign(snapshot, ref creatorFreeAccessUsers) ||
this.TryAssign(snapshot, ref subscriberChannels) ||
this.TryAssign(snapshot, ref subscriber) ||
this.TryAssign(snapshot, ref calculatedAccountBalance);
if (!assigned)
{
throw new InvalidOperationException("Unknown snapshot type: " + snapshot.GetType().Name);
}
var newMergedSnapshot = new MergedSnapshot(creatorChannels, creatorFreeAccessUsers, subscriberChannels, subscriber, calculatedAccountBalance);
if (mergedSnapshots.Count > 0 && mergedSnapshots.Last().Timestamp == snapshot.Timestamp)
{
mergedSnapshots.RemoveAt(mergedSnapshots.Count - 1);
}
mergedSnapshots.Add(newMergedSnapshot);
}
return(mergedSnapshots);
}
private static MergedSnapshot CreateSnapshot(DateTime timestamp)
{
return(new MergedSnapshot(
timestamp,
CreatorChannelsSnapshot.Default(Now, UserId.Random()),
CreatorFreeAccessUsersSnapshot.Default(Now, UserId.Random()),
SubscriberChannelsSnapshot.Default(Now, UserId.Random()),
SubscriberSnapshot.Default(Now, UserId.Random()),
CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(Now, UserId.Random())));
}
private static List <MergedSnapshot> CreateMergedSnapshotResult()
{
return(new List <MergedSnapshot>
{
new MergedSnapshot(
CreatorChannelsSnapshot.Default(Now, UserId.Random()),
CreatorFreeAccessUsersSnapshot.Default(Now, UserId.Random()),
SubscriberChannelsSnapshot.Default(Now, UserId.Random()),
SubscriberSnapshot.Default(Now, UserId.Random()),
CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(Now, UserId.Random()))
});
}
public void ItShouldReturnTheGivenSnapshots()
{
var now = DateTime.UtcNow;
var input = new List <MergedSnapshot>
{
new MergedSnapshot(
CreatorChannelsSnapshot.Default(now, UserId.Random()),
CreatorFreeAccessUsersSnapshot.Default(now, UserId.Random()),
SubscriberChannelsSnapshot.Default(now, UserId.Random()),
SubscriberSnapshot.Default(now, UserId.Random()),
CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(now, UserId.Random())),
};
Assert.AreSame(input, this.target.Execute(input));
}
public void ItShouldSetTheTimeStampToTheMaximumOfItsComponents()
{
Assert.AreEqual(
Now.AddDays(1),
new MergedSnapshot(
CreatorChannelsSnapshot.Default(Now.AddDays(1), UserId.Random()),
CreatorFreeAccessUsersSnapshot.Default(Now, UserId.Random()),
SubscriberChannelsSnapshot.Default(Now, UserId.Random()),
SubscriberSnapshot.Default(Now, UserId.Random()),
CalculatedAccountBalanceSnapshot.Default(Now, UserId.Random(), default(LedgerAccountType))).Timestamp);
Assert.AreEqual(
Now.AddDays(1),
new MergedSnapshot(
CreatorChannelsSnapshot.Default(Now, UserId.Random()),
CreatorFreeAccessUsersSnapshot.Default(Now.AddDays(1), UserId.Random()),
SubscriberChannelsSnapshot.Default(Now, UserId.Random()),
SubscriberSnapshot.Default(Now, UserId.Random()),
CalculatedAccountBalanceSnapshot.Default(Now, UserId.Random(), default(LedgerAccountType))).Timestamp);
Assert.AreEqual(
Now.AddDays(1),
new MergedSnapshot(
CreatorChannelsSnapshot.Default(Now, UserId.Random()),
CreatorFreeAccessUsersSnapshot.Default(Now, UserId.Random()),
SubscriberChannelsSnapshot.Default(Now.AddDays(1), UserId.Random()),
SubscriberSnapshot.Default(Now, UserId.Random()),
CalculatedAccountBalanceSnapshot.Default(Now, UserId.Random(), default(LedgerAccountType))).Timestamp);
Assert.AreEqual(
Now.AddDays(1),
new MergedSnapshot(
CreatorChannelsSnapshot.Default(Now, UserId.Random()),
CreatorFreeAccessUsersSnapshot.Default(Now, UserId.Random()),
SubscriberChannelsSnapshot.Default(Now, UserId.Random()),
SubscriberSnapshot.Default(Now.AddDays(1), UserId.Random()),
CalculatedAccountBalanceSnapshot.Default(Now, UserId.Random(), default(LedgerAccountType))).Timestamp);
Assert.AreEqual(
Now.AddDays(1),
new MergedSnapshot(
CreatorChannelsSnapshot.Default(Now, UserId.Random()),
CreatorFreeAccessUsersSnapshot.Default(Now, UserId.Random()),
SubscriberChannelsSnapshot.Default(Now, UserId.Random()),
SubscriberSnapshot.Default(Now, UserId.Random()),
CalculatedAccountBalanceSnapshot.Default(Now.AddDays(1), UserId.Random(), default(LedgerAccountType))).Timestamp);
}
public void WhenSingleSnapshot_WhenDateIsNotEndDate_ItShouldNotModifyCollection()
{
var input = new List <MergedSnapshot>
{
new MergedSnapshot(
Now.AddDays(1),
CreatorChannelsSnapshot.Default(Now, UserId.Random()),
CreatorFreeAccessUsersSnapshot.Default(Now, UserId.Random()),
this.subscriberChannels,
SubscriberSnapshot.Default(Now, UserId.Random()),
CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(Now, UserId.Random()))
};
var output = this.target.Execute(input);
CollectionAssert.AreEqual(input, output.ToList());
}
public void WhenTwoSnapshots_WhenDatesOnEndDatesButStraddleEndDates_ItShouldModifyCollection()
{
var input = new List <MergedSnapshot>
{
new MergedSnapshot(
Now,
CreatorChannelsSnapshot.Default(Now, UserId.Random()),
CreatorFreeAccessUsersSnapshot.Default(Now, UserId.Random()),
this.subscriberChannels,
SubscriberSnapshot.Default(Now, UserId.Random()),
CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(Now, UserId.Random())),
new MergedSnapshot(
Now.AddDays(21),
CreatorChannelsSnapshot.Default(Now, UserId.Random()),
CreatorFreeAccessUsersSnapshot.Default(Now, UserId.Random()),
SubscriberChannelsSnapshot.Default(Now, UserId.Random()),
SubscriberSnapshot.Default(Now, UserId.Random()),
CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(Now, UserId.Random()))
};
var expected = new List <MergedSnapshot>
{
input[0],
new MergedSnapshot(
Now.AddDays(7),
input[0].CreatorChannels,
input[0].CreatorFreeAccessUsers,
input[0].SubscriberChannels,
input[0].Subscriber,
input[0].CalculatedAccountBalance),
new MergedSnapshot(
Now.AddDays(14),
input[0].CreatorChannels,
input[0].CreatorFreeAccessUsers,
input[0].SubscriberChannels,
input[0].Subscriber,
input[0].CalculatedAccountBalance),
input[1],
};
var output = this.target.Execute(input);
CollectionAssert.AreEqual(expected, output.ToList());
}
public void WhenSnapshotsAreLessThanEndDate_ItShouldReturn()
{
this.target.Execute(
StartTimeInclusive,
EndTimeExclusive,
SubscriberId1,
CreatorId1,
new List <ISnapshot>
{
CreatorChannelsSnapshot.Default(Now, CreatorId1),
CreatorChannelsSnapshot.Default(Now, CreatorId1),
CreatorChannelsSnapshot.Default(Now.AddSeconds(1), CreatorId1),
SubscriberChannelsSnapshot.Default(Now.AddSeconds(1), SubscriberId1),
SubscriberChannelsSnapshot.Default(Now.AddSeconds(2), SubscriberId1),
CreatorFreeAccessUsersSnapshot.Default(Now.AddSeconds(2), CreatorId1),
CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(Now.AddSeconds(2), SubscriberId1),
SubscriberSnapshot.Default(EndTimeExclusive.AddTicks(-1), SubscriberId1),
});
}
public void WhenSnapshotsAreUnorderedAndValid_ItShouldThrowAnException()
{
this.target.Execute(
StartTimeInclusive,
EndTimeExclusive,
SubscriberId1,
CreatorId1,
new List <ISnapshot>
{
CreatorChannelsSnapshot.Default(Now, CreatorId1),
CreatorChannelsSnapshot.Default(Now, CreatorId1),
CreatorChannelsSnapshot.Default(Now.AddSeconds(1), CreatorId1),
SubscriberChannelsSnapshot.Default(Now.AddSeconds(2), SubscriberId1),
SubscriberChannelsSnapshot.Default(Now.AddSeconds(1), SubscriberId1),
CreatorFreeAccessUsersSnapshot.Default(Now.AddSeconds(2), CreatorId1),
SubscriberSnapshot.Default(Now.AddSeconds(2), SubscriberId1),
CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(Now.AddSeconds(2), SubscriberId1),
});
}
public void WhenCreatorGuestListSnapshotHasInvalidCreatorId_ItShouldThrowAnException()
{
this.target.Execute(
StartTimeInclusive,
EndTimeExclusive,
SubscriberId1,
CreatorId1,
new List <ISnapshot>
{
CreatorChannelsSnapshot.Default(Now, CreatorId1),
CreatorChannelsSnapshot.Default(Now, CreatorId1),
CreatorChannelsSnapshot.Default(Now.AddSeconds(1), CreatorId1),
SubscriberChannelsSnapshot.Default(Now.AddSeconds(1), SubscriberId1),
SubscriberChannelsSnapshot.Default(Now.AddSeconds(2), SubscriberId1),
CreatorFreeAccessUsersSnapshot.Default(Now.AddSeconds(2), new UserId(Guid.NewGuid())),
SubscriberSnapshot.Default(Now.AddSeconds(2), SubscriberId1),
CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(Now.AddSeconds(2), SubscriberId1),
});
}
public void WhenOnlyCalculatedAccountBalanceSnapshot_ShouldReturnMergedSnapshot()
{
var calculatedAccountBalanceSnapshot = new CalculatedAccountBalanceSnapshot(Now, SubscriberId1, LedgerAccountType.FifthweekCredit, 10);
var expectedResult = new MergedSnapshot(
Now,
CreatorChannelsSnapshot.Default(Now, CreatorId1),
CreatorFreeAccessUsersSnapshot.Default(Now, CreatorId1),
SubscriberChannelsSnapshot.Default(Now, SubscriberId1),
SubscriberSnapshot.Default(Now, SubscriberId1),
calculatedAccountBalanceSnapshot);
var result = this.target.Execute(SubscriberId1, CreatorId1, Now, new List <ISnapshot> {
calculatedAccountBalanceSnapshot
});
CollectionAssert.AreEqual(new List <MergedSnapshot> {
expectedResult
}, result.ToList());
}
public void WhenSubscriptionTimeStampIsNotUtc_ItShouldThrowAnException()
{
this.target.Execute(
StartTimeInclusive,
EndTimeExclusive,
SubscriberId1,
CreatorId1,
new List <ISnapshot>
{
CreatorChannelsSnapshot.Default(Now, CreatorId1),
CreatorChannelsSnapshot.Default(Now, CreatorId1),
CreatorChannelsSnapshot.Default(Now.AddSeconds(1), CreatorId1),
SubscriberChannelsSnapshot.Default(Now.AddSeconds(1), SubscriberId1),
new SubscriberChannelsSnapshot(Now.AddSeconds(2), SubscriberId1, new List <SubscriberChannelsSnapshotItem> {
new SubscriberChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100, DateTime.Now)
}),
CreatorFreeAccessUsersSnapshot.Default(Now.AddSeconds(2), CreatorId1),
CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(Now.AddSeconds(2), SubscriberId1),
SubscriberSnapshot.Default(Now.AddSeconds(2), SubscriberId1),
});
}
public void WhenSimultaniousSnapshots_ShouldMergeCorrectly()
{
var creatorChannelSnapshot = new CreatorChannelsSnapshot(Now, CreatorId1, new List <CreatorChannelsSnapshotItem> {
new CreatorChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100)
});
var creatorGuestListSnapshot = new CreatorFreeAccessUsersSnapshot(Now, CreatorId1, new List <string> {
"a", "b"
});
var subscriberChannelSnapshot = new SubscriberChannelsSnapshot(Now, SubscriberId1, new List <SubscriberChannelsSnapshotItem> {
new SubscriberChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100, Now)
});
var subscriberSnapshot = new SubscriberSnapshot(Now, SubscriberId1, "email");
var calculatedAccountBalanceSnapshot = new CalculatedAccountBalanceSnapshot(Now, SubscriberId1, LedgerAccountType.FifthweekCredit, 10);
var expectedResult = new List <MergedSnapshot>
{
new MergedSnapshot(
Now,
creatorChannelSnapshot,
creatorGuestListSnapshot,
subscriberChannelSnapshot,
subscriberSnapshot,
calculatedAccountBalanceSnapshot),
};
var result = this.target.Execute(
SubscriberId1,
CreatorId1,
Now,
new List <ISnapshot>
{
creatorChannelSnapshot,
subscriberChannelSnapshot,
creatorGuestListSnapshot,
subscriberSnapshot,
calculatedAccountBalanceSnapshot
});
CollectionAssert.AreEqual(expectedResult, result.ToList());
}
public void WhenOnlySubscriberChannelSnapshot_ShouldReturnMergedSnapshot()
{
var subscriberChannelSnapshot = new SubscriberChannelsSnapshot(Now, SubscriberId1, new List <SubscriberChannelsSnapshotItem> {
new SubscriberChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100, Now)
});
var expectedResult = new MergedSnapshot(
Now,
CreatorChannelsSnapshot.Default(Now, CreatorId1),
CreatorFreeAccessUsersSnapshot.Default(Now, CreatorId1),
subscriberChannelSnapshot,
SubscriberSnapshot.Default(Now, SubscriberId1),
CalculatedAccountBalanceSnapshot.Default(Now, SubscriberId1, LedgerAccountType.FifthweekCredit));
var result = this.target.Execute(SubscriberId1, CreatorId1, Now, new List <ISnapshot> {
subscriberChannelSnapshot
});
CollectionAssert.AreEqual(new List <MergedSnapshot> {
expectedResult
}, result.ToList());
}
private static MergedSnapshot CreateSnapshot(DateTime subscriptionStartDate, DateTime timestamp, bool channel1Subscribed, bool channel2Subscribed, BillingWeekEndTimeType endTimeType, DateTime?innerTimestamp = null)
{
var creatorChannels = new List <CreatorChannelsSnapshotItem> {
new CreatorChannelsSnapshotItem(ChannelId1, 100), new CreatorChannelsSnapshotItem(ChannelId2, 100)
};
var subscriberChannels = new List <SubscriberChannelsSnapshotItem>();
var channel1StartDate = subscriptionStartDate;
var channel2StartDate = subscriptionStartDate;
if (endTimeType == BillingWeekEndTimeType.Channel1First)
{
channel2StartDate = channel2StartDate.AddMinutes(10);
}
else if (endTimeType == BillingWeekEndTimeType.Channel2First)
{
channel1StartDate = channel2StartDate.AddMinutes(10);
}
if (channel1Subscribed)
{
subscriberChannels.Add(new SubscriberChannelsSnapshotItem(ChannelId1, 100, channel1StartDate));
}
if (channel2Subscribed)
{
subscriberChannels.Add(new SubscriberChannelsSnapshotItem(ChannelId2, 100, channel2StartDate));
}
return(new MergedSnapshot(
timestamp,
new CreatorChannelsSnapshot(innerTimestamp ?? timestamp, CreatorId1, creatorChannels),
CreatorFreeAccessUsersSnapshot.Default(innerTimestamp ?? timestamp, CreatorId1),
new SubscriberChannelsSnapshot(innerTimestamp ?? timestamp, SubscriberId1, subscriberChannels),
SubscriberSnapshot.Default(innerTimestamp ?? timestamp, SubscriberId1),
CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(innerTimestamp ?? timestamp, SubscriberId1)));
}
public void WhenSequenceOfSnapshots_ShouldReturnSnapshotAtSnapshotTime()
{
var input = new List <ISnapshot>
{
new CreatorChannelsSnapshot(Now.AddHours(1), CreatorId1, new List <CreatorChannelsSnapshotItem> {
new CreatorChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100)
}),
new CreatorFreeAccessUsersSnapshot(Now.AddHours(2), CreatorId1, new List <string> {
"a", "b"
}),
new SubscriberChannelsSnapshot(Now.AddHours(3), SubscriberId1, new List <SubscriberChannelsSnapshotItem> {
new SubscriberChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100, Now)
}),
new CreatorFreeAccessUsersSnapshot(Now.AddHours(4), CreatorId1, new List <string> {
"a", "b"
}),
new CreatorChannelsSnapshot(Now.AddHours(5), CreatorId1, new List <CreatorChannelsSnapshotItem> {
new CreatorChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100)
}),
new SubscriberChannelsSnapshot(Now.AddHours(5), SubscriberId1, new List <SubscriberChannelsSnapshotItem> {
new SubscriberChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100, Now)
}),
new SubscriberChannelsSnapshot(Now.AddHours(6), SubscriberId1, new List <SubscriberChannelsSnapshotItem> {
new SubscriberChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100, Now)
}),
new SubscriberSnapshot(Now.AddHours(7), SubscriberId1, "email"),
new CalculatedAccountBalanceSnapshot(Now.AddHours(8), SubscriberId1, LedgerAccountType.FifthweekCredit, 10)
};
var defaultCreatorChannelSnapshot = CreatorChannelsSnapshot.Default(Now, CreatorId1);
var defaultCreatorGuestListSnapshot = CreatorFreeAccessUsersSnapshot.Default(Now, CreatorId1);
var defaultSubscriberChannelSnapshot = SubscriberChannelsSnapshot.Default(Now, SubscriberId1);
var defaultSubscriberSnapshot = SubscriberSnapshot.Default(Now, SubscriberId1);
var defaultCalculatedAccountBalanceSnapshot = CalculatedAccountBalanceSnapshot.Default(Now, SubscriberId1, LedgerAccountType.FifthweekCredit);
var expectedResult = new List <MergedSnapshot>
{
new MergedSnapshot(
Now,
defaultCreatorChannelSnapshot,
defaultCreatorGuestListSnapshot,
defaultSubscriberChannelSnapshot,
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(1),
(CreatorChannelsSnapshot)input[0],
defaultCreatorGuestListSnapshot,
defaultSubscriberChannelSnapshot,
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(2),
(CreatorChannelsSnapshot)input[0],
(CreatorFreeAccessUsersSnapshot)input[1],
defaultSubscriberChannelSnapshot,
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(3),
(CreatorChannelsSnapshot)input[0],
(CreatorFreeAccessUsersSnapshot)input[1],
(SubscriberChannelsSnapshot)input[2],
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(4),
(CreatorChannelsSnapshot)input[0],
(CreatorFreeAccessUsersSnapshot)input[3],
(SubscriberChannelsSnapshot)input[2],
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(5),
(CreatorChannelsSnapshot)input[4],
(CreatorFreeAccessUsersSnapshot)input[3],
(SubscriberChannelsSnapshot)input[5],
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(6),
(CreatorChannelsSnapshot)input[4],
(CreatorFreeAccessUsersSnapshot)input[3],
(SubscriberChannelsSnapshot)input[6],
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(7),
(CreatorChannelsSnapshot)input[4],
(CreatorFreeAccessUsersSnapshot)input[3],
(SubscriberChannelsSnapshot)input[6],
(SubscriberSnapshot)input[7],
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(8),
(CreatorChannelsSnapshot)input[4],
(CreatorFreeAccessUsersSnapshot)input[3],
(SubscriberChannelsSnapshot)input[6],
(SubscriberSnapshot)input[7],
(CalculatedAccountBalanceSnapshot)input[8]),
};
var result = this.target.Execute(SubscriberId1, CreatorId1, Now, input);
CollectionAssert.AreEqual(expectedResult, result.ToList());
}
public void WhenSeriesOfSnapshots_ItShouldReturnCostPeriods()
{
var snapshots = new List <ISnapshot>
{
new CreatorChannelsSnapshot(Now.AddHours(1), CreatorId1, new List <CreatorChannelsSnapshotItem> {
new CreatorChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100)
}),
new CreatorFreeAccessUsersSnapshot(Now.AddHours(2), CreatorId1, new List <string> {
"a", "b"
}),
new SubscriberChannelsSnapshot(Now.AddHours(3), SubscriberId1, new List <SubscriberChannelsSnapshotItem> {
new SubscriberChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100, Now)
}),
new CreatorFreeAccessUsersSnapshot(Now.AddHours(4), CreatorId1, new List <string> {
"a", "b"
}),
new CreatorChannelsSnapshot(Now.AddHours(5), CreatorId1, new List <CreatorChannelsSnapshotItem> {
new CreatorChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100)
}),
new SubscriberChannelsSnapshot(Now.AddHours(5), SubscriberId1, new List <SubscriberChannelsSnapshotItem> {
new SubscriberChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100, Now)
}),
new SubscriberSnapshot(Now.AddHours(6), SubscriberId1, "email"),
new SubscriberChannelsSnapshot(Now.AddHours(6), SubscriberId1, new List <SubscriberChannelsSnapshotItem> {
new SubscriberChannelsSnapshotItem(new ChannelId(Guid.NewGuid()), 100, Now)
})
};
var defaultCreatorChannelSnapshot = CreatorChannelsSnapshot.Default(Now, CreatorId1);
var defaultCreatorGuestListSnapshot = CreatorFreeAccessUsersSnapshot.Default(Now, CreatorId1);
var defaultSubscriberChannelSnapshot = SubscriberChannelsSnapshot.Default(Now, SubscriberId1);
var defaultSubscriberSnapshot = SubscriberSnapshot.Default(Now, SubscriberId1);
var defaultCalculatedAccountBalanceSnapshot = CalculatedAccountBalanceSnapshot.DefaultFifthweekCreditAccount(Now, UserId.Random());
var mergedSnapshots = new List <MergedSnapshot>
{
new MergedSnapshot(
Now,
defaultCreatorChannelSnapshot,
defaultCreatorGuestListSnapshot,
defaultSubscriberChannelSnapshot,
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(1),
(CreatorChannelsSnapshot)snapshots[0],
defaultCreatorGuestListSnapshot,
defaultSubscriberChannelSnapshot,
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(2),
(CreatorChannelsSnapshot)snapshots[0],
(CreatorFreeAccessUsersSnapshot)snapshots[1],
defaultSubscriberChannelSnapshot,
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(3),
(CreatorChannelsSnapshot)snapshots[0],
(CreatorFreeAccessUsersSnapshot)snapshots[1],
(SubscriberChannelsSnapshot)snapshots[2],
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(4),
(CreatorChannelsSnapshot)snapshots[0],
(CreatorFreeAccessUsersSnapshot)snapshots[3],
(SubscriberChannelsSnapshot)snapshots[2],
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(5),
(CreatorChannelsSnapshot)snapshots[4],
(CreatorFreeAccessUsersSnapshot)snapshots[3],
(SubscriberChannelsSnapshot)snapshots[5],
defaultSubscriberSnapshot,
defaultCalculatedAccountBalanceSnapshot),
new MergedSnapshot(
Now.AddHours(6),
(CreatorChannelsSnapshot)snapshots[4],
(CreatorFreeAccessUsersSnapshot)snapshots[3],
(SubscriberChannelsSnapshot)snapshots[7],
(SubscriberSnapshot)snapshots[6],
defaultCalculatedAccountBalanceSnapshot),
};
this.costCalculator.Setup(v => v.Execute(It.IsAny <MergedSnapshot>(), creatorPosts))
.Returns <MergedSnapshot, IReadOnlyList <CreatorPost> >((s, p) => (int)Math.Round((s.Timestamp - Now).TotalHours + 10));
var expectedOutput = new List <CostPeriod>
{
new CostPeriod(Now.AddHours(0), Now.AddHours(1), 10),
new CostPeriod(Now.AddHours(1), Now.AddHours(2), 11),
new CostPeriod(Now.AddHours(2), Now.AddHours(3), 12),
new CostPeriod(Now.AddHours(3), Now.AddHours(4), 13),
new CostPeriod(Now.AddHours(4), Now.AddHours(5), 14),
new CostPeriod(Now.AddHours(5), Now.AddHours(6), 15),
new CostPeriod(Now.AddHours(6), Now.AddHours(10), 16),
};
var result = this.target.Execute(Now, Now.AddHours(10), mergedSnapshots, creatorPosts);
CollectionAssert.AreEqual(expectedOutput, result.ToList());
}
