Exemple #1
0
        public async Task IncludesOnlyCommon()
        {
            var timestamp = DateTime.UtcNow;

            await Task.WhenAll(
                userActivity.Track("bought-apple", timestamp, 1, 2, 3, 4),
                userActivity.Track("bought-banana", timestamp, 3, 4, 5, 6));

            var apple  = userActivity.Report("bought-apple", timestamp);
            var banana = userActivity.Report("bought-banana", timestamp);
            var both   = apple & banana;

            var results = await both.Includes(0, 1, 2, 3, 4, 5, 6, 7);

            for (var i = 0; i < results.Length; i++)
            {
                if (i > 2 && i < 5)
                {
                    Assert.True(results[i]);
                }
                else
                {
                    Assert.False(results[i]);
                }
            }
        }
Exemple #2
0
        public async Task AndOnlyIncludesCommon()
        {
            var timestamp = DateTime.UtcNow;

            await Task.WhenAll(
                userActivity.Track("bought-apple", timestamp, 1, 2, 3, 4),
                userActivity.Track("bought-banana", timestamp, 3, 4, 5, 6),
                userActivity.Track("bought-mango", timestamp, 2, 4, 6));

            var apple          = userActivity.Report("bought-apple", timestamp);
            var banana         = userActivity.Report("bought-banana", timestamp);
            var mango          = userActivity.Report("bought-mango", timestamp);
            var appleAndBanana = apple & banana;

            var all     = appleAndBanana & mango;
            var results = await all.Includes(1, 2, 3, 4, 5, 6);

            for (var i = 0; i < results.Length; i++)
            {
                if (i == 3)
                {
                    Assert.True(results[i]);
                }
                else
                {
                    Assert.False(results[i]);
                }
            }
        }
        public async Task RemovesAllTrackedEvents()
        {
            await Task.WhenAll(
                userActivity.Track("foo", 1),
                userActivity.Track("bar", 2),
                userActivity.Track("baz", 3));

            var count = await userActivity.Reset();

            // 3 tracked events and 1 for event names
            Assert.Equal(4, count);
        }
        public async Task ReturnsSumOfExclusives()
        {
            var timestamp = DateTime.UtcNow;

            await Task.WhenAll(
                userActivity.Track("bought-apple", timestamp, 1, 2, 3, 4),
                userActivity.Track("bought-banana", timestamp, 3, 4, 5, 6));

            var apple  = userActivity.Report("bought-apple", timestamp);
            var banana = userActivity.Report("bought-banana", timestamp);
            var both   = apple ^ banana;
            var count  = await both.Count();

            Assert.Equal(4, count);
        }
        public async Task RetunsTrueIfPreviouslyStored()
        {
            var timestamp = DateTime.UtcNow;

            await userActivity.Track(EventName, timestamp, 97);

            await userActivity.Track(EventName, timestamp, 98);

            await userActivity.Track(EventName, timestamp, 99);

            var result = await userActivity.Report(EventName, timestamp)
                         .Includes(98);

            Assert.True(result.First());
        }
 protected UserActivityTrackTests(ActivityTimeframe timeframe)
 {
     UserActivity = new UserActivity(
         new ActivitySettings(1, timeframe));
     UserActivity.Reset().Wait();
     UserActivity.Track(EventName, Timestamp, 1, 2, 3).Wait();
 }
        public async Task ExchangesMessage()
        {
            const string EventName = "login";
            var          timestamp = DateTime.UtcNow;

            var signal = new ManualResetEvent(false);

            var subscription = activity.CreateSubscription();

            await subscription.Subscribe(
                EventName,
                e =>
            {
                Assert.Equal(EventName, e.EventName);
                Assert.Equal(timestamp, e.Timestamp);
                Assert.Contains(1, e.Users);
                Assert.Contains(2, e.Users);
                Assert.Contains(3, e.Users);
                signal.Set();
            });

            await activity.Track(EventName, true, 1, 2, 3);

            signal.WaitOne(TimeSpan.FromSeconds(1));

            await subscription.Unsubscribe(EventName);

            subscription.Dispose();
        }
 protected UserActivityTrackTests(ActivityTimeframe timeframe)
 {
     UserActivity = new UserActivity(
         new ActivitySettings(1, timeframe));
     UserActivity.Reset().Wait();
     UserActivity.Track(EventName, Timestamp, 1, 2, 3).Wait();
 }
 protected UserActivityTrackTests(ActivityDrilldown drilldown)
 {
     UserActivity = new UserActivity(
         new ActivitySettings(1, drilldown));
     UserActivity.Reset().Wait();
     UserActivity.Track(EventName, Timestamp, 1, 2, 3).Wait();
 }
 protected UserActivityTrackTests(ActivityDrilldown drilldown)
 {
     UserActivity = new UserActivity(
         new ActivitySettings(1, drilldown));
     UserActivity.Reset().Wait();
     UserActivity.Track(EventName, Timestamp, 1, 2, 3).Wait();
 }
        public async Task ReturnsTrackedEventsCount()
        {
            var timestamp = DateTime.UtcNow;

            await userActivity.Track(EventName, timestamp, 100, 204, 1002, 3);

            var count = await userActivity.Report(EventName, timestamp).Count();

            Assert.Equal(4, count);
        }
        public async Task ReturnsAllTrackedEventNames()
        {
            var timestamp     = DateTime.UtcNow;
            var inputedEvents = new List <string>();

            for (var i = 1; i <= 5; i++)
            {
                await userActivity.Track("event-" + i, timestamp, i);
            }

            var outputedEvents = await userActivity.EventNames();

            inputedEvents.ForEach(n => Assert.Contains(n, outputedEvents));
        }