コード例 #1
0
        public void Indexing_Centralized_Sql_UpdateStateToDone()
        {
            var connectionStringBackup = Configuration.ConnectionStrings.ConnectionString;

            Configuration.ConnectionStrings.ConnectionString = _connectionString;
            try
            {
                CleanupIndexingActivitiesTable();

                var lastActivityIdBefore = DataProvider.Current.GetLastIndexingActivityId();
                DataProvider.Current.RegisterIndexingActivity(
                    CreateActivity(
                        IndexingActivityType.AddDocument, "/Root/Indexing_Centralized_Sql_UpdateStateToDone", 42, 42, 99999999, null));
                var lastActivityIdAfter = DataProvider.Current.GetLastIndexingActivityId();

                var factory          = new IndexingActivityFactory();
                var loadedActivities = DataProvider.Current.LoadIndexingActivities(lastActivityIdBefore + 1, lastActivityIdAfter, 1000, false, factory).ToArray();
                if (loadedActivities.Length != 1)
                {
                    Assert.Inconclusive("Successful test needs one IndexingActivity.");
                }
                var loadedActivity = loadedActivities[0];
                if (loadedActivity == null)
                {
                    Assert.Inconclusive("Successful test needs the existing IndexingActivity.");
                }
                if (loadedActivity.RunningState != IndexingActivityRunningState.Waiting)
                {
                    Assert.Inconclusive("Successful test needs the requirement: ActivityState is IndexingActivityState.Waiting.");
                }

                // action
                DataProvider.Current.UpdateIndexingActivityRunningState(loadedActivity.Id, IndexingActivityRunningState.Done);

                // check
                var lastActivityIdAfterUpdate = DataProvider.Current.GetLastIndexingActivityId();
                Assert.AreEqual(lastActivityIdAfter, lastActivityIdAfterUpdate);

                loadedActivity = DataProvider.Current.LoadIndexingActivities(lastActivityIdBefore + 1, lastActivityIdAfter, 1000, false, factory).First();
                Assert.AreEqual(IndexingActivityRunningState.Done, loadedActivity.RunningState);
            }
            finally
            {
                Configuration.ConnectionStrings.ConnectionString = connectionStringBackup;
            }
        }
コード例 #2
0
        public async Task Indexing_Centralized_UpdateStateToDone()
        {
            await NoRepoIntegrationTestAsync(async() =>
            {
                await DP.DeleteAllIndexingActivitiesAsync(CancellationToken.None);
                var lastActivityIdBefore = await DP.GetLastIndexingActivityIdAsync(CancellationToken.None);
                await DP.RegisterIndexingActivityAsync(
                    CreateActivity(
                        IndexingActivityType.AddDocument, "/Root/Indexing_Centralized_UpdateStateToDone", 42, 42, 99999999, null), CancellationToken.None);
                var lastActivityIdAfter = await DP.GetLastIndexingActivityIdAsync(CancellationToken.None);

                var factory          = new IndexingActivityFactory();
                var loadedActivities = await DP.LoadIndexingActivitiesAsync(lastActivityIdBefore + 1, lastActivityIdAfter, 1000, false, factory, CancellationToken.None);
                if (loadedActivities.Length != 1)
                {
                    Assert.Inconclusive("Successful test needs one IndexingActivity.");
                }
                var loadedActivity = loadedActivities[0];
                if (loadedActivity == null)
                {
                    Assert.Inconclusive("Successful test needs the existing IndexingActivity.");
                }
                if (loadedActivity.RunningState != IndexingActivityRunningState.Waiting)
                {
                    Assert.Inconclusive("Successful test needs the requirement: ActivityState is IndexingActivityState.Waiting.");
                }

                // action
                await DP.UpdateIndexingActivityRunningStateAsync(loadedActivity.Id, IndexingActivityRunningState.Done, CancellationToken.None);

                // check
                var lastActivityIdAfterUpdate = await DP.GetLastIndexingActivityIdAsync(CancellationToken.None);
                Assert.AreEqual(lastActivityIdAfter, lastActivityIdAfterUpdate);

                loadedActivity = (await DP.LoadIndexingActivitiesAsync(lastActivityIdBefore + 1, lastActivityIdAfter, 1000, false, factory, CancellationToken.None)).First();
                Assert.AreEqual(IndexingActivityRunningState.Done, loadedActivity.RunningState);
            });
        }
コード例 #3
0
        public void Indexing_Centralized_InMemory_UpdateStateToDone()
        {
            using (new Tests.Tools.DataProviderSwindler(new InMemoryDataProvider()))
            {
                var lastActivityIdBefore = DataProvider.Current.GetLastIndexingActivityId();
                DataProvider.Current.RegisterIndexingActivity(
                    CreateActivity(
                        IndexingActivityType.AddDocument, "/Root/Indexing_Centralized_InMemory_UpdateStateToDone", 42, 42, 99999999, null));
                var lastActivityIdAfter = DataProvider.Current.GetLastIndexingActivityId();

                var factory          = new IndexingActivityFactory();
                var loadedActivities = DataProvider.Current.LoadIndexingActivities(lastActivityIdBefore + 1, lastActivityIdAfter, 1000, false, factory).ToArray();
                if (loadedActivities.Length != 1)
                {
                    Assert.Inconclusive("Successful test needs one IndexingActivity.");
                }
                var loadedActivity = loadedActivities[0];
                if (loadedActivity == null)
                {
                    Assert.Inconclusive("Successful test needs the existing IndexingActivity.");
                }
                if (loadedActivity.RunningState != IndexingActivityRunningState.Waiting)
                {
                    Assert.Inconclusive("Successful test needs the requirement: ActivityState is IndexingActivityState.Waiting.");
                }

                // action
                DataProvider.Current.UpdateIndexingActivityRunningState(loadedActivity.Id, IndexingActivityRunningState.Done);

                // check
                var lastActivityIdAfterUpdate = DataProvider.Current.GetLastIndexingActivityId();
                Assert.AreEqual(lastActivityIdAfter, lastActivityIdAfterUpdate);

                loadedActivity = DataProvider.Current.LoadIndexingActivities(lastActivityIdBefore + 1, lastActivityIdAfter, 1000, false, factory).First();
                Assert.AreEqual(IndexingActivityRunningState.Done, loadedActivity.RunningState);
            }
        }
コード例 #4
0
        public async Task Indexing_Centralized_RegisterAndReload()
        {
            await NoRepoIntegrationTestAsync(async() =>
            {
                // Ensure an existing activity to get right last activity id.
                await DP.RegisterIndexingActivityAsync(
                    CreateActivity(IndexingActivityType.AddDocument, "/Root/42", 42, 42, 99999999, null),
                    CancellationToken.None);
                var lastActivityIdBefore = await DP.GetLastIndexingActivityIdAsync(CancellationToken.None);
                await DP.DeleteAllIndexingActivitiesAsync(CancellationToken.None);

                var timeAtStart = DateTime.UtcNow;

                // avoid rounding errors: reloaded datetime can be less than timeAtStart
                // if rounding in sql converts the input to smaller value.
                Thread.Sleep(10);

                var activities = new[]
                {
                    CreateActivity(IndexingActivityType.AddDocument, "/Root/42", 42, 42, 99999999, null),
                    CreateActivity(IndexingActivityType.UpdateDocument, "/Root/43", 43, 43, 99999999, null),
                    CreateTreeActivity(IndexingActivityType.AddTree, "/Root/44", 44, null),
                    CreateTreeActivity(IndexingActivityType.RemoveTree, "/Root/45", 45, null),
                    CreateActivity(IndexingActivityType.Rebuild, "/Root/46", 46, 46, 99999999, null),
                };

                foreach (var activity in activities)
                {
                    await DP.RegisterIndexingActivityAsync(activity, CancellationToken.None);
                }

                // avoid rounding errors: reloaded datetime can be greater than timeAtEnd
                // if rounding in sql converts the input to greater value.
                Thread.Sleep(10);

                var timeAtEnd = DateTime.UtcNow;

                var lastActivityIdAfter = await DP.GetLastIndexingActivityIdAsync(CancellationToken.None);
                Assert.AreEqual(lastActivityIdBefore + 5, lastActivityIdAfter);

                var factory = new IndexingActivityFactory();

                // ---- simulating system start
                var unprocessedActivities = await DP.LoadIndexingActivitiesAsync(lastActivityIdBefore + 1,
                                                                                 lastActivityIdAfter, 1000, true, factory, CancellationToken.None);
                Assert.AreEqual(5, unprocessedActivities.Length);
                Assert.AreEqual(
                    $"{IndexingActivityType.AddDocument}, {IndexingActivityType.UpdateDocument}, {IndexingActivityType.AddTree}, {IndexingActivityType.RemoveTree}, {IndexingActivityType.Rebuild}",
                    string.Join(", ", unprocessedActivities.Select(x => x.ActivityType.ToString()).ToArray()));
                Assert.AreEqual(
                    "42, 43, 44, 45, 46",
                    string.Join(", ", unprocessedActivities.Select(x => x.NodeId.ToString()).ToArray()));
                Assert.AreEqual(
                    "42, 43, 0, 0, 46",
                    string.Join(", ", unprocessedActivities.Select(x => x.VersionId.ToString()).ToArray()));
                Assert.AreEqual(
                    "/root/42, /root/43, /root/44, /root/45, /root/46",
                    string.Join(", ", unprocessedActivities.Select(x => x.Path)));

                for (int i = 0; i < unprocessedActivities.Length; i++)
                {
                    Assert.AreEqual(lastActivityIdBefore + i + 1, unprocessedActivities[i].Id);
                    Assert.IsTrue(timeAtStart <= unprocessedActivities[i].CreationDate &&
                                  unprocessedActivities[i].CreationDate <= timeAtEnd);
                    Assert.IsTrue(unprocessedActivities[i].IsUnprocessedActivity);
                    Assert.AreEqual(IndexingActivityRunningState.Waiting, unprocessedActivities[i].RunningState);
                    Assert.IsNull(unprocessedActivities[i].LockTime);
                }

                // ---- simulating runtime maintenance
                var loadedActivities = await DP.LoadIndexingActivitiesAsync(lastActivityIdBefore + 1,
                                                                            lastActivityIdAfter, 1000, false, factory, CancellationToken.None);
                Assert.AreEqual(5, loadedActivities.Length);
                Assert.AreEqual(
                    $"{IndexingActivityType.AddDocument}, {IndexingActivityType.UpdateDocument}, {IndexingActivityType.AddTree}, {IndexingActivityType.RemoveTree}, {IndexingActivityType.Rebuild}",
                    string.Join(", ", loadedActivities.Select(x => x.ActivityType.ToString()).ToArray()));
                Assert.AreEqual(
                    "42, 43, 44, 45, 46",
                    string.Join(", ", loadedActivities.Select(x => x.NodeId.ToString()).ToArray()));
                Assert.AreEqual(
                    "42, 43, 0, 0, 46",
                    string.Join(", ", loadedActivities.Select(x => x.VersionId.ToString()).ToArray()));
                Assert.AreEqual(
                    "/root/42, /root/43, /root/44, /root/45, /root/46",
                    string.Join(", ", loadedActivities.Select(x => x.Path)));

                for (int i = 0; i < loadedActivities.Length; i++)
                {
                    Assert.AreEqual(lastActivityIdBefore + i + 1, loadedActivities[i].Id);
                    Assert.IsTrue(timeAtStart <= loadedActivities[i].CreationDate &&
                                  loadedActivities[i].CreationDate <= timeAtEnd);
                    Assert.IsFalse(loadedActivities[i].IsUnprocessedActivity);
                    Assert.AreEqual(IndexingActivityRunningState.Waiting, unprocessedActivities[i].RunningState);
                    Assert.IsNull(unprocessedActivities[i].LockTime);
                }

                var gaps = new[] { lastActivityIdBefore + 1, lastActivityIdBefore + 2 };
                // ---- simulating system start
                var unprocessedActivitiesFromGaps = await DP.LoadIndexingActivitiesAsync(gaps, true, factory, CancellationToken.None);
                Assert.AreEqual(
                    $"{lastActivityIdBefore + 1}, {lastActivityIdBefore + 2}",
                    string.Join(", ", unprocessedActivitiesFromGaps.Select(x => x.Id.ToString()).ToArray()));
                Assert.AreEqual(
                    "True, True",
                    string.Join(", ",
                                unprocessedActivitiesFromGaps.Select(x => x.IsUnprocessedActivity.ToString()).ToArray()));
                // ---- simulating runtime maintenance
                var loadedActivitiesFromGaps = await DP.LoadIndexingActivitiesAsync(gaps, false, factory, CancellationToken.None);
                Assert.AreEqual(
                    $"{lastActivityIdBefore + 1}, {lastActivityIdBefore + 2}",
                    string.Join(", ", loadedActivitiesFromGaps.Select(x => x.Id.ToString()).ToArray()));
                Assert.AreEqual(
                    "False, False",
                    string.Join(", ",
                                loadedActivitiesFromGaps.Select(x => x.IsUnprocessedActivity.ToString()).ToArray()));
            });
        }
コード例 #5
0
        public void Indexing_Centralized_Sql_RegisterAndReload()
        {
            var connectionStringBackup = Configuration.ConnectionStrings.ConnectionString;

            Configuration.ConnectionStrings.ConnectionString = _connectionString;
            try
            {
                CleanupIndexingActivitiesTable();

                var lastActivityIdBefore = DataProvider.Current.GetLastIndexingActivityId();

                var timeAtStart = DateTime.UtcNow;

                // avoid rounding errors: reloaded datetime can be less than timeAtStart
                // if rounding in sql converts the input to smaller value.
                Thread.Sleep(10);

                var activities = new[]
                {
                    CreateActivity(IndexingActivityType.AddDocument, "/Root/42", 42, 42, 99999999, null),
                    CreateActivity(IndexingActivityType.UpdateDocument, "/Root/43", 43, 43, 99999999, null),
                    CreateTreeActivity(IndexingActivityType.AddTree, "/Root/44", 44, null),
                    CreateTreeActivity(IndexingActivityType.RemoveTree, "/Root/45", 45, null),
                    CreateActivity(IndexingActivityType.Rebuild, "/Root/46", 46, 46, 99999999, null),
                };

                foreach (var activity in activities)
                {
                    DataProvider.Current.RegisterIndexingActivity(activity);
                }

                // avoid rounding errors: reloaded datetime can be greater than timeAtEnd
                // if rounding in sql converts the input to greater value.
                Thread.Sleep(10);

                var timeAtEnd = DateTime.UtcNow;

                var lastActivityIdAfter = DataProvider.Current.GetLastIndexingActivityId();
                Assert.AreEqual(lastActivityIdBefore + 5, lastActivityIdAfter);

                var factory = new IndexingActivityFactory();

                // ---- simulating system start
                var unprocessedActivities = DataProvider.Current.LoadIndexingActivities(lastActivityIdBefore + 1, lastActivityIdAfter, 1000, true, factory);
                Assert.AreEqual(5, unprocessedActivities.Length);
                Assert.AreEqual(
                    $"{IndexingActivityType.AddDocument}, {IndexingActivityType.UpdateDocument}, {IndexingActivityType.AddTree}, {IndexingActivityType.RemoveTree}, {IndexingActivityType.Rebuild}",
                    string.Join(", ", unprocessedActivities.Select(x => x.ActivityType.ToString()).ToArray()));
                Assert.AreEqual(
                    "42, 43, 44, 45, 46",
                    string.Join(", ", unprocessedActivities.Select(x => x.NodeId.ToString()).ToArray()));
                Assert.AreEqual(
                    "42, 43, 0, 0, 46",
                    string.Join(", ", unprocessedActivities.Select(x => x.VersionId.ToString()).ToArray()));
                Assert.AreEqual(
                    "/root/42, /root/43, /root/44, /root/45, /root/46",
                    string.Join(", ", unprocessedActivities.Select(x => x.Path)));

                for (int i = 0; i < unprocessedActivities.Length; i++)
                {
                    Assert.AreEqual(lastActivityIdBefore + i + 1, unprocessedActivities[i].Id);
                    Assert.IsTrue(timeAtStart <= unprocessedActivities[i].CreationDate && unprocessedActivities[i].CreationDate <= timeAtEnd);
                    Assert.IsTrue(unprocessedActivities[i].IsUnprocessedActivity);
                    Assert.AreEqual(IndexingActivityRunningState.Waiting, unprocessedActivities[i].RunningState);
                    Assert.IsNull(unprocessedActivities[i].LockTime);
                }

                // ---- simulating runtime maintenance
                var loadedActivities = DataProvider.Current.LoadIndexingActivities(lastActivityIdBefore + 1, lastActivityIdAfter, 1000, false, factory);
                Assert.AreEqual(5, loadedActivities.Length);
                Assert.AreEqual(
                    $"{IndexingActivityType.AddDocument}, {IndexingActivityType.UpdateDocument}, {IndexingActivityType.AddTree}, {IndexingActivityType.RemoveTree}, {IndexingActivityType.Rebuild}",
                    string.Join(", ", loadedActivities.Select(x => x.ActivityType.ToString()).ToArray()));
                Assert.AreEqual(
                    "42, 43, 44, 45, 46",
                    string.Join(", ", loadedActivities.Select(x => x.NodeId.ToString()).ToArray()));
                Assert.AreEqual(
                    "42, 43, 0, 0, 46",
                    string.Join(", ", loadedActivities.Select(x => x.VersionId.ToString()).ToArray()));
                Assert.AreEqual(
                    "/root/42, /root/43, /root/44, /root/45, /root/46",
                    string.Join(", ", loadedActivities.Select(x => x.Path)));

                for (int i = 0; i < loadedActivities.Length; i++)
                {
                    Assert.AreEqual(lastActivityIdBefore + i + 1, loadedActivities[i].Id);
                    Assert.IsTrue(timeAtStart <= loadedActivities[i].CreationDate && loadedActivities[i].CreationDate <= timeAtEnd);
                    Assert.IsFalse(loadedActivities[i].IsUnprocessedActivity);
                    Assert.AreEqual(IndexingActivityRunningState.Waiting, unprocessedActivities[i].RunningState);
                    Assert.IsNull(unprocessedActivities[i].LockTime);
                }

                var gaps = new[] { lastActivityIdBefore + 1, lastActivityIdBefore + 2 };
                // ---- simulating system start
                var unprocessedActivitiesFromGaps = DataProvider.Current.LoadIndexingActivities(gaps, true, factory);
                Assert.AreEqual(
                    $"{lastActivityIdBefore + 1}, {lastActivityIdBefore + 2}",
                    string.Join(", ", unprocessedActivitiesFromGaps.Select(x => x.Id.ToString()).ToArray()));
                Assert.AreEqual(
                    "True, True",
                    string.Join(", ", unprocessedActivitiesFromGaps.Select(x => x.IsUnprocessedActivity.ToString()).ToArray()));
                // ---- simulating runtime maintenance
                var loadedActivitiesFromGaps = DataProvider.Current.LoadIndexingActivities(gaps, false, factory);
                Assert.AreEqual(
                    $"{lastActivityIdBefore + 1}, {lastActivityIdBefore + 2}",
                    string.Join(", ", loadedActivitiesFromGaps.Select(x => x.Id.ToString()).ToArray()));
                Assert.AreEqual(
                    "False, False",
                    string.Join(", ", loadedActivitiesFromGaps.Select(x => x.IsUnprocessedActivity.ToString()).ToArray()));
            }
            finally
            {
                Configuration.ConnectionStrings.ConnectionString = connectionStringBackup;
            }
        }