public async Task ExampleUsage1()
{
// Create an analytics system and fill it with feature usage events:
var analytics = CreateLocalAnalyticsSystem();
var t = new MockDateTimeV2();
IoC.inject.SetSingleton <DateTimeV2>(t);
string featureId = "feature1";
{
var startDate = DateTimeV2.ParseUtc("01.01.2011");
var endDate = DateTimeV2.ParseUtc("19.01.2011");
SimulateUsage(featureId, 100, t, startDate, endDate);
await AssertFeatureUsageDetected(analytics, featureId, 100);
}
t.mockUtcNow = DateTimeV2.ParseUtc("01.02.2011");
await TestAllRules1(analytics, featureId);
{ // Simulate more usage in the next 5 days:
var startDate = DateTimeV2.ParseUtc("20.01.2011");
var endDate = DateTimeV2.ParseUtc("25.01.2011");
SimulateUsage(featureId, 100, t, startDate, endDate);
await AssertFeatureUsageDetected(analytics, featureId, 200);
}
// Simulate a month without any usage:
t.mockUtcNow = DateTimeV2.ParseUtc("01.03.2011");
await TestAllRules2(analytics, featureId);
{ // Simulate that a usage notification is shown and test the related rule:
var notificationId = "notification1";
var daysAgo = 20;
t.mockUtcNow = DateTimeV2.ParseUtc("01.03.2011");
// Simulate that notification1 is shown to the user (e.g. by the usageRule system):
AppFlow.TrackEvent(EventConsts.catUsage, EventConsts.SHOW + "_" + notificationId);
t.mockUtcNow = DateTimeV2.ParseUtc("02.03.2011"); // Simulate a day passing by
UsageRule notificationMinXDaysOld = analytics.NewNotificationMinXDaysOldRule(notificationId, daysAgo);
Assert.False(await notificationMinXDaysOld.isTrue());
Assert.False(await notificationMinXDaysOld.IsNotificationMinXDaysOld(analytics));
t.mockUtcNow = DateTimeV2.ParseUtc("25.03.2011"); // Simulate more time passing by
Assert.True(await notificationMinXDaysOld.IsNotificationMinXDaysOld(analytics));
Assert.True(await notificationMinXDaysOld.isTrue());
// Simulate a second show of the notification:
AppFlow.TrackEvent(EventConsts.catUsage, EventConsts.SHOW + "_" + notificationId);
Assert.True(await notificationMinXDaysOld.IsNotificationMinXDaysOld(analytics));
Assert.True(await notificationMinXDaysOld.isTrue());
}
}
async Task TestAllRules1(LocalAnalytics analytics, string featureId)
{
var daysUsed = 20;
var timesUsed = 200;
UsageRule featureUsedXDays = analytics.NewFeatureUsedXDaysRule(featureId, daysUsed);
Assert.False(await featureUsedXDays.isTrue());
Assert.False(await featureUsedXDays.IsFeatureUsedXDays(analytics)); // Used by .isTrue
UsageRule featureNotUsedXDays = analytics.NewFeatureNotUsedXDaysRule(featureId, daysUsed);
Assert.True(await featureNotUsedXDays.isTrue());
UsageRule appNotUsedXDays = analytics.NewAppNotUsedXDaysRule(daysUsed);
Assert.True(await appNotUsedXDays.isTrue());
UsageRule featureNotUsedXTimes = analytics.NewFeatureNotUsedXTimesRule(featureId, timesUsed);
Assert.True(await featureNotUsedXTimes.isTrue());
UsageRule appUsedInTheLastXDays = analytics.NewAppUsedInTheLastXDaysRule(daysUsed);
Assert.True(await appUsedInTheLastXDays.isTrue());
UsageRule appNotUsedInTheLastXDays = analytics.NewAppNotUsedInTheLastXDaysRule(daysUsed);
Assert.False(await appNotUsedInTheLastXDays.isTrue());
UsageRule featureUsedInTheLastXDays = analytics.NewFeatureUsedInTheLastXDaysRule(featureId, daysUsed);
Assert.True(await featureUsedInTheLastXDays.isTrue());
{ // Compose a more complex usage rule out of multiple rules:
UsageRule appUsedXDays = analytics.NewAppUsedXDaysRule(daysUsed);
Assert.False(await appUsedXDays.isTrue());
UsageRule featureUsedXTimes = analytics.NewFeatureUsedXTimesRule(featureId, timesUsed);
Assert.False(await featureUsedXTimes.isTrue());
UsageRule featureNotUsedInTheLastXDays = analytics.NewFeatureNotUsedInTheLastXDaysRule(featureId, daysUsed);
Assert.False(await featureNotUsedInTheLastXDays.isTrue());
UsageRule featureNotUsedAnymoreRule = analytics.NewConcatRule(
appUsedXDays, featureUsedXTimes, featureNotUsedInTheLastXDays
);
Assert.False(await featureNotUsedAnymoreRule.isTrue());
UsageRule clone = featureNotUsedAnymoreRule.DeepCopyViaJson();
clone.SetupUsing(analytics);
Assert.False(await clone.isTrue());
}
}
public void RemoveUsageRule_WithUnknownUsageRule_Succeeds()
{
var contentKey = TestHelpers.GenerateContentKey();
var rule = new UsageRule
{
KeyId = contentKey.Id
};
var document = new CpixDocument();
document.ContentKeys.Add(contentKey);
document.UsageRules.Remove(rule);
}
public void RemoveUsageRule_WithLoadedWritableCollection_Succeeds()
{
var contentKey = TestHelpers.GenerateContentKey();
var rule = new UsageRule
{
KeyId = contentKey.Id
};
var document = new CpixDocument();
document.ContentKeys.Add(contentKey);
document.UsageRules.Add(rule);
document = TestHelpers.Reload(document);
document.UsageRules.Remove(document.UsageRules.Single());
}
public void RoundTrip_WithSignedCollection_Succeeds()
{
var contentKey = TestHelpers.GenerateContentKey();
var rule = new UsageRule
{
KeyId = contentKey.Id
};
var document = new CpixDocument();
document.ContentKeys.Add(contentKey);
document.UsageRules.Add(rule);
document.UsageRules.AddSignature(TestHelpers.Certificate1WithPrivateKey);
document = TestHelpers.Reload(document);
Assert.Single(document.UsageRules);
}
public void TestExplicitExcludeOverRidesExplicitIncludeUsageRules()
{
//IList<UsageRule> usageRules, IList<string> assemblyFolders
UsageRule excludeUsageRule = new UsageRule {
MatchType = UsageRuleNameMatch.DirectoryFullName, Name = RootFolder, UsageRuleFunction = UsageRuleFunction.Exclude, UsageRuleDepth = UsageRuleDepth.CurrentFolderOnly
};
UsageRule includeUsageRule = new UsageRule {
MatchType = UsageRuleNameMatch.DirectoryFullName, Name = RootFolder, UsageRuleFunction = UsageRuleFunction.Include, UsageRuleDepth = UsageRuleDepth.CurrentFolderOnly
};
IList <UsageRule> combinedUsageRules = new List <UsageRule> {
includeUsageRule, excludeUsageRule,
};
IList <string> assemblyFolders = new List <string>();
//prove that it will find the folder for include
RuleApplicator.AddAllRecursiveIncludeUsagesToFolder(new List <UsageRule> {
includeUsageRule
}, assemblyFolders);
Assert.AreEqual(1, assemblyFolders.Count);
Assert.Contains(RootFolder, assemblyFolders.ToArray());
//prove that it will Not get it the folder for exclude
assemblyFolders = new List <string> {
RootFolder
};
RuleApplicator.RemoveAllRecursiveExcludeUsagesFromFolder(new List <UsageRule> {
excludeUsageRule
}, assemblyFolders);
Assert.AreEqual(0, assemblyFolders.Count);
assemblyFolders = new List <string> {
RootFolder, Dir6
};
RuleApplicator.RemoveAllRecursiveExcludeUsagesFromFolder(new List <UsageRule> {
excludeUsageRule
}, assemblyFolders);
Assert.AreEqual(1, assemblyFolders.Count);
Assert.Contains(Dir6, assemblyFolders.ToArray());
//prove that used in combined list exclude will override include
assemblyFolders = RuleApplicator.ApplyAllUsageRules(combinedUsageRules);
Assert.AreEqual(0, assemblyFolders.Count);
}
public void ResolveContentKey_WithUnsupportedFilters_Fails()
{
var key = TestHelpers.GenerateContentKey();
var document = new CpixDocument();
document.ContentKeys.Add(key);
// This matches all contexts.
document.UsageRules.Add(new UsageRule
{
KeyId = key.Id
});
// This matches some crazy label AND contains unsupported filters.
// The presence of this should be enough to completely disable any key resolving.
var rule = new UsageRule
{
KeyId = key.Id,
LabelFilters = new[]
{
new LabelFilter
{
Label = "299999999999999999999999999999999999"
}
}
};
document.UsageRules.Add(rule);
// We do this after Add() since normally such filters cannot be added (and save would also reject it).
rule.ContainsUnsupportedFilters = true;
Assert.Throws <NotSupportedException>(() => document.ResolveContentKey(new ContentKeyContext()));
}
public static UsageRule AddUsageRule(CpixDocument document)
{
var contentKey = document.ContentKeys.First();
var rule = new UsageRule
{
KeyId = contentKey.Id,
// Some arbitrary filters here, just to generate interesting test data.
AudioFilters = new[]
{
new AudioFilter
{
MaxChannels = 5,
MinChannels = 0
}
},
BitrateFilters = new[]
{
new BitrateFilter
{
MinBitrate = 100,
MaxBitrate = 5198493
},
new BitrateFilter
{
MinBitrate = 5198494,
MaxBitrate = 100000000000000
}
},
LabelFilters = new[]
{
new LabelFilter("aaaaa"),
new LabelFilter("bbbb"),
},
VideoFilters = new[]
{
new VideoFilter
{
MinPixels = 1000,
MaxPixels = 1920 * 1080,
MinFramesPerSecond = 10,
MaxFramesPerSecond = 30,
WideColorGamut = false,
HighDynamicRange = true,
},
new VideoFilter
{
MinPixels = 1000,
MaxPixels = 4096 * 4096,
MinFramesPerSecond = 30,
MaxFramesPerSecond = 200,
WideColorGamut = false,
HighDynamicRange = false,
}
}
};
document.UsageRules.Add(rule);
return(rule);
}
