Bug fix/internal issue #586 (#9401)

* Removet lazy creation ob analyzers collection. Test fixes (added explicit creation of analyzers collection for test enviroments)

* Fixed test runs. Removed cluster tests for analyzer DDL

* Analyzers collection name moved to tests common

* Disbaled load_library in normalize calls

* Legacy code cleanup

* added db analyzers collection checks in analyzer creation test to cover functions removed from gtest

* Reverted analyzer properties comparsion to non-utf8 as that must be binary equal

arangod/IResearch/IResearchAnalyzerFeature.cpp

@@ -303,7 +303,8 @@ irs::analysis::analyzer::ptr text_vpack_builder(irs::string_ref const& args) noe
 bool text_vpack_normalizer(const irs::string_ref& args, std::string& out) noexcept {
   std::string tmp;
   if (irs::analysis::analyzers::normalize(tmp, "text", irs::text_format::json,
-                                          arangodb::iresearch::slice<char>(args).toString())) {
+                                          arangodb::iresearch::slice<char>(args).toString(), 
+                                          false)) {
     auto vpack = VPackParser::fromJson(tmp);
     out.resize(vpack->slice().byteSize());
     std::memcpy(&out[0], vpack->slice().begin(), out.size());
@@ -327,7 +328,7 @@ namespace stem_vpack {
   bool stem_vpack_normalizer(const irs::string_ref& args, std::string& out) noexcept {
     std::string tmp;
     if (irs::analysis::analyzers::normalize(tmp, "stem", irs::text_format::json,
-      arangodb::iresearch::slice<char>(args).toString())) {
+      arangodb::iresearch::slice<char>(args).toString(), false)) {
       auto vpack = VPackParser::fromJson(tmp);
       out.resize(vpack->slice().byteSize());
       std::memcpy(&out[0], vpack->slice().begin(), out.size());
@@ -351,7 +352,7 @@ namespace norm_vpack {
   bool norm_vpack_normalizer(const irs::string_ref& args, std::string& out) noexcept {
     std::string tmp;
     if (irs::analysis::analyzers::normalize(tmp, "norm", irs::text_format::json,
-      arangodb::iresearch::slice<char>(args).toString())) {
+      arangodb::iresearch::slice<char>(args).toString(), false)) {
       auto vpack = VPackParser::fromJson(tmp);
       out.resize(vpack->slice().byteSize());
       std::memcpy(&out[0], vpack->slice().begin(), out.size());
@@ -500,6 +501,9 @@ bool equalAnalyzer(
 
   if (!::normalize(normalizedProperties, type, properties)) {
     // failed to normalize definition
+    LOG_TOPIC("dfac1", WARN, arangodb::iresearch::TOPIC)
+      << "failed to normalize properties for analyzer type '" << type << "' properties '"
+      << properties.toString() << "'";
     return false;
   }
 
@@ -1157,12 +1161,22 @@ arangodb::Result IResearchAnalyzerFeature::emplaceAnalyzer( // emplace
 
     erase = false;
   } else if (!equalAnalyzer(*analyzer, type, properties, features)) { // duplicate analyzer with different configuration
-    return arangodb::Result(
-      TRI_ERROR_BAD_PARAMETER,
-      "name collision detected while registering an arangosearch analizer name '" + std::string(name) +
-      "' type '" + std::string(type) + "' properties '" + properties.toString() +
-      "', previous registration type '" + std::string(analyzer->type()) +
-      "' properties '" + analyzer->properties().toString() + "'");
+    std::ostringstream errorText;
+    errorText << "name collision detected while registering an arangosearch analyzer name '" << name
+      << "' type '" << type << "' properties '" << properties.toString()
+      << "' features '"; 
+    for(auto feature : features) {
+      errorText << feature->name() << " ";
+    }   
+    errorText << "', previous registration type '" << analyzer->type()
+      << "' properties '" << analyzer->properties().toString() << "'"
+      << " features '";
+    for(auto feature : analyzer->features()) {
+      errorText << feature->name() << " ";
+    }
+    errorText << "'";
+    return arangodb::Result(TRI_ERROR_BAD_PARAMETER, errorText.str());
+    
   }
 
   result = itr;
@@ -2227,35 +2241,14 @@ arangodb::Result IResearchAnalyzerFeature::storeAnalyzer(AnalyzerPool& pool) {
 
   try {
     auto collection = getAnalyzerCollection(*vocbase);
-
     if (!collection) {
-      auto collectionCallback = [&collection]( // store collection
-        std::shared_ptr<arangodb::LogicalCollection> const& col // args
-      )->void {
-        collection = col;
-      };
-      static auto const properties = // analyzer collection properties
-        arangodb::velocypack::Parser::fromJson("{ \"isSystem\": true }");
-      auto res = arangodb::methods::Collections::create( // create collection
-        *vocbase, // collection vocbase
-        ANALYZER_COLLECTION_NAME, // collection name
-        TRI_col_type_e::TRI_COL_TYPE_DOCUMENT, // collection type
-        properties->slice(), // collection properties
-        true, // waitsForSyncReplication same as UpgradeTasks::createSystemCollection(...)
-        true, // enforceReplicationFactor same as UpgradeTasks::createSystemCollection(...)
-        collectionCallback // callback if created
-      );
-
-      if (!res.ok()) {
-        return res;
-      }
-
-      if (!collection) {
-        return arangodb::Result( // result
-          TRI_ERROR_INTERNAL, // code
-          std::string("failure to create collection '") + ANALYZER_COLLECTION_NAME + "' in vocbase '" + vocbase->name() + "' vocbase while persising arangosearch analyzer '" + pool.name()+ "'"
-        );
-      }
+       return arangodb::Result( // result
+         TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND, // code
+         std::string("failure to find collection '") + 
+             ANALYZER_COLLECTION_NAME + 
+             "' in vocbase '" + vocbase->name() + 
+             "' vocbase while persising arangosearch analyzer '" + pool.name()+ "'"
+       );
     }
 
     arangodb::SingleCollectionTransaction trx( // transaction

tests/IResearch/IResearchDocument-test.cpp

@@ -51,6 +51,7 @@
 #include "Transaction/Methods.h"
 #include "Transaction/StandaloneContext.h"
 #include "V8Server/V8DealerFeature.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "velocypack/Builder.h"
 #include "velocypack/Iterator.h"
@@ -204,7 +205,12 @@ class IResearchDocumentTest : public ::testing::Test {
         f.first->start();
       }
     }
-
+    {
+      auto vocbase = dbFeature->useDatabase(arangodb::StaticStrings::SystemDatabase);
+      arangodb::methods::Collections::createSystem(
+          *vocbase,
+          arangodb::tests::AnalyzerCollectionName);
+    }
     auto* analyzers =
         arangodb::application_features::ApplicationServer::lookupFeature<arangodb::iresearch::IResearchAnalyzerFeature>();
     arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;

tests/IResearch/IResearchFilterBoolean-test.cpp

@@ -57,6 +57,7 @@
 #include "StorageEngine/EngineSelectorFeature.h"
 #include "Transaction/StandaloneContext.h"
 #include "V8Server/V8DealerFeature.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "analysis/analyzers.hpp"
 #include "analysis/token_attributes.hpp"
@@ -175,7 +176,9 @@ class IResearchFilterBooleanTest : public ::testing::Test {
     TRI_vocbase_t* vocbase;
 
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
-
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
     analyzers->emplace(
       result,
       "testVocbase::test_analyzer",

tests/IResearch/IResearchFilterCompare-test.cpp

@@ -58,6 +58,7 @@
 #include "Transaction/Methods.h"
 #include "Transaction/StandaloneContext.h"
 #include "V8Server/V8DealerFeature.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "analysis/analyzers.hpp"
 #include "analysis/token_attributes.hpp"
@@ -176,7 +177,9 @@ class IResearchFilterCompareTest : public ::testing::Test {
     TRI_vocbase_t* vocbase;
 
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
-
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
     analyzers->emplace(
       result,
       "testVocbase::test_analyzer",

tests/IResearch/IResearchFilterFunction-test.cpp

@@ -59,6 +59,7 @@
 #include "Transaction/Methods.h"
 #include "Transaction/StandaloneContext.h"
 #include "V8Server/V8DealerFeature.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "analysis/analyzers.hpp"
 #include "analysis/token_attributes.hpp"
@@ -178,6 +179,9 @@ class IResearchFilterFunctionTest : public ::testing::Test {
     TRI_vocbase_t* vocbase;
 
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
+    arangodb::methods::Collections::createSystem(
+        *vocbase,
+        arangodb::tests::AnalyzerCollectionName);
     analyzers->emplace(result, "testVocbase::test_analyzer", "TestAnalyzer",
                        VPackParser::fromJson("\"abc\"")->slice());  // cache analyzer
   }

tests/IResearch/IResearchFilterIn-test.cpp

@@ -57,6 +57,7 @@
 #include "StorageEngine/EngineSelectorFeature.h"
 #include "Transaction/StandaloneContext.h"
 #include "V8Server/V8DealerFeature.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "analysis/analyzers.hpp"
 #include "analysis/token_attributes.hpp"
@@ -175,6 +176,9 @@ class IResearchFilterInTest : public ::testing::Test {
     TRI_vocbase_t* vocbase;
 
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
+    arangodb::methods::Collections::createSystem(
+        *vocbase,
+        arangodb::tests::AnalyzerCollectionName);
     analyzers->emplace(
       result,
       "testVocbase::test_analyzer",

tests/IResearch/IResearchIndex-test.cpp

@@ -60,6 +60,7 @@
 #include "V8Server/V8DealerFeature.h"
 #include "VocBase/LogicalCollection.h"
 #include "VocBase/LogicalView.h"
+#include "VocBase/Methods/Collections.h"
 #include "utils/utf8_path.hpp"
 #include "velocypack/Iterator.h"
 #include "velocypack/Parser.h"
@@ -246,6 +247,9 @@ class IResearchIndexTest : public ::testing::Test {
     TRI_vocbase_t* vocbase;
 
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
+    arangodb::methods::Collections::createSystem(
+        *vocbase,
+        arangodb::tests::AnalyzerCollectionName);
     analyzers->emplace(result, "testVocbase::test_A", "TestInsertAnalyzer", arangodb::velocypack::Parser::fromJson("{ \"args\": \"X\" }")->slice());
     analyzers->emplace(result, "testVocbase::test_B", "TestInsertAnalyzer", arangodb::velocypack::Parser::fromJson("{ \"args\": \"Y\" }")->slice());
 

tests/IResearch/IResearchLinkHelper-test.cpp

@@ -50,6 +50,7 @@
 #include "Utils/ExecContext.h"
 #include "V8Server/V8DealerFeature.h"
 #include "VocBase/LogicalCollection.h"
+#include "VocBase/Methods/Collections.h"
 #include "utils/misc.hpp"
 #include "velocypack/Parser.h"
 
@@ -281,11 +282,9 @@ TEST_F(IResearchLinkHelperTest, test_normalize) {
 
   // create analyzer collection
   {
-    static std::string const ANALYZER_COLLECTION_NAME("_iresearch_analyzers");
-
-    if (!sysVocbase->lookupCollection(ANALYZER_COLLECTION_NAME)) {
+    if (!sysVocbase->lookupCollection(arangodb::tests::AnalyzerCollectionName)) {
       auto collectionJson = arangodb::velocypack::Parser::fromJson(
-          std::string("{ \"name\": \"") + ANALYZER_COLLECTION_NAME +
+          std::string("{ \"name\": \"") + arangodb::tests::AnalyzerCollectionName +
           "\", \"isSystem\": true }");
       auto logicalCollection = sysVocbase->createCollection(collectionJson->slice());
       ASSERT_TRUE((false == !logicalCollection));
@@ -328,27 +327,6 @@ TEST_F(IResearchLinkHelperTest, test_normalize) {
                                          "::testAnalyzer2")));
   }
 
-  // analyzer single-server (no engine) fail persist if not storage engine, else SEGFAULT in Methods(...)
-  {
-    auto json = arangodb::velocypack::Parser::fromJson(
-        "{ \
-      \"analyzerDefinitions\": [ { \"name\": \"testAnalyzer2\", \"type\": \"identity\" } ], \
-      \"analyzers\": [\"testAnalyzer2\" ] \
-    }");
-    auto* before = arangodb::EngineSelectorFeature::ENGINE;
-    arangodb::EngineSelectorFeature::ENGINE = nullptr;
-    auto restore = irs::make_finally([&before]() -> void {
-      arangodb::EngineSelectorFeature::ENGINE = before;
-    });
-    arangodb::velocypack::Builder builder;
-    builder.openObject();
-    EXPECT_TRUE((false == arangodb::iresearch::IResearchLinkHelper::normalize(
-                              builder, json->slice(), false, *sysVocbase)
-                              .ok()));
-    EXPECT_TRUE((true == !analyzers->get(arangodb::StaticStrings::SystemDatabase +
-                                         "::testAnalyzer3")));
-  }
-
   // analyzer coordinator
   {
     auto json = arangodb::velocypack::Parser::fromJson(
@@ -514,6 +492,16 @@ TEST_F(IResearchLinkHelperTest, test_updateLinks) {
     ASSERT_TRUE(
         (TRI_ERROR_NO_ERROR == dbFeature->createDatabase(1, "testVocbase", vocbase)));  // required for IResearchAnalyzerFeature::emplace(...)
     ASSERT_TRUE((nullptr != vocbase));
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
+  
+    {
+      auto* sysDb = dbFeature->useDatabase(arangodb::StaticStrings::SystemDatabase);
+      arangodb::methods::Collections::createSystem(
+          *sysDb, 
+          arangodb::tests::AnalyzerCollectionName);
+    }
     auto dropDB = irs::make_finally([dbFeature]() -> void {
       dbFeature->dropDatabase("testVocbase", true, true);
     });

tests/IResearch/IResearchLinkMeta-test.cpp

@@ -57,6 +57,7 @@
 #include "velocypack/Builder.h"
 #include "velocypack/Iterator.h"
 #include "velocypack/Parser.h"
+#include "VocBase/Methods/Collections.h"
 
 namespace {
 
@@ -177,9 +178,16 @@ class IResearchLinkMetaTest : public ::testing::Test {
       }
     }
 
+    auto sysvocbase = dbFeature->useDatabase(arangodb::StaticStrings::SystemDatabase);
+    arangodb::methods::Collections::createSystem(
+        *sysvocbase,
+        arangodb::tests::AnalyzerCollectionName);
+
     TRI_vocbase_t* vocbase;
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
-
+    arangodb::methods::Collections::createSystem(
+        *vocbase,
+        arangodb::tests::AnalyzerCollectionName);
     auto* analyzers =
         arangodb::application_features::ApplicationServer::lookupFeature<arangodb::iresearch::IResearchAnalyzerFeature>();
     arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;

tests/IResearch/IResearchQueryAnd-test.cpp

@@ -57,6 +57,7 @@
 #include "V8Server/V8DealerFeature.h"
 #include "VocBase/LogicalCollection.h"
 #include "VocBase/LogicalView.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "3rdParty/iresearch/tests/tests_config.hpp"
 #include "Transaction/StandaloneContext.h"
@@ -157,7 +158,9 @@ class IResearchQueryAndTest : public ::testing::Test {
 
     
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
-
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
   
     analyzers->emplace(result, "testVocbase::test_analyzer", "TestAnalyzer",
                        VPackParser::fromJson("\"abc\"")->slice());  // cache analyzer

tests/IResearch/IResearchQueryComplexBoolean-test.cpp

@@ -61,6 +61,7 @@
 #include "V8Server/V8DealerFeature.h"
 #include "VocBase/LogicalCollection.h"
 #include "VocBase/LogicalView.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "IResearch/VelocyPackHelper.h"
 #include "analysis/analyzers.hpp"
@@ -157,6 +158,10 @@ class IResearchQueryComplexBooleanTest : public ::testing::Test {
     TRI_vocbase_t* vocbase;
 
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
+    arangodb::methods::Collections::createSystem(
+        *vocbase,
+        arangodb::tests::AnalyzerCollectionName);
+
     analyzers->emplace(result, "testVocbase::test_analyzer", "TestAnalyzer",
                        VPackParser::fromJson("\"abc\"")->slice(), 
                        irs::flags{irs::frequency::type(), irs::position::type()}  // required for PHRASE

tests/IResearch/IResearchQueryInRange-test.cpp

@@ -59,6 +59,7 @@
 #include "V8Server/V8DealerFeature.h"
 #include "VocBase/LogicalCollection.h"
 #include "VocBase/LogicalView.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "3rdParty/iresearch/tests/tests_config.hpp"
 #include "Transaction/StandaloneContext.h"
@@ -152,7 +153,9 @@ class IResearchQueryInRangeTest : public ::testing::Test {
         arangodb::application_features::ApplicationServer::lookupFeature<arangodb::DatabaseFeature>(
             "Database");
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
-
+    arangodb::methods::Collections::createSystem(
+        *vocbase,
+        arangodb::tests::AnalyzerCollectionName);
     auto* analyzers =
         arangodb::application_features::ApplicationServer::lookupFeature<arangodb::iresearch::IResearchAnalyzerFeature>();
 

tests/IResearch/IResearchQueryJoin-test.cpp

@@ -67,6 +67,7 @@
 #include "VocBase/LogicalCollection.h"
 #include "VocBase/LogicalView.h"
 #include "VocBase/ManagedDocumentResult.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "IResearch/VelocyPackHelper.h"
 #include "analysis/analyzers.hpp"
@@ -200,6 +201,9 @@ class IResearchQueryJoinTest : public ::testing::Test {
     TRI_vocbase_t* vocbase;
 
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
     analyzers->emplace(result, "testVocbase::test_analyzer", "TestAnalyzer",
                        VPackParser::fromJson("\"abc\"")->slice());  // cache analyzer
     analyzers->emplace(result, "testVocbase::test_csv_analyzer",

tests/IResearch/IResearchQueryOr-test.cpp

@@ -62,6 +62,7 @@
 #include "VocBase/LogicalCollection.h"
 #include "VocBase/LogicalView.h"
 #include "VocBase/ManagedDocumentResult.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "IResearch/VelocyPackHelper.h"
 #include "analysis/analyzers.hpp"
@@ -157,6 +158,9 @@ class IResearchQueryOrTest : public ::testing::Test {
     TRI_vocbase_t* vocbase;
 
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
+    arangodb::methods::Collections::createSystem(
+        *vocbase,
+        arangodb::tests::AnalyzerCollectionName);
     analyzers->emplace(result, "testVocbase::test_analyzer", "TestAnalyzer",
                        VPackParser::fromJson("\"abc\"")->slice(),
                        irs::flags{irs::frequency::type(), irs::position::type()}  // required for PHRASE

tests/IResearch/IResearchQueryPhrase-test.cpp

@@ -61,6 +61,7 @@
 #include "V8Server/V8DealerFeature.h"
 #include "VocBase/LogicalCollection.h"
 #include "VocBase/LogicalView.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "IResearch/VelocyPackHelper.h"
 #include "analysis/analyzers.hpp"
@@ -156,6 +157,9 @@ class IResearchQueryPhraseTest : public ::testing::Test {
     EXPECT_TRUE(sysVocBaseFeature);
 
     auto sysVocBasePtr = sysVocBaseFeature->use();
+    arangodb::methods::Collections::createSystem(
+        *sysVocBasePtr, 
+        arangodb::tests::AnalyzerCollectionName);
 
     auto* analyzers =
         arangodb::application_features::ApplicationServer::lookupFeature<arangodb::iresearch::IResearchAnalyzerFeature>();
@@ -163,6 +167,9 @@ class IResearchQueryPhraseTest : public ::testing::Test {
     TRI_vocbase_t* vocbase;
 
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
     analyzers->emplace(result, "testVocbase::test_analyzer", "TestAnalyzer",
                        VPackParser::fromJson("\"abc\"")->slice(), 
                        irs::flags{irs::frequency::type(), irs::position::type()}  // required for PHRASE

tests/IResearch/IResearchQueryScorer-test.cpp

@@ -67,6 +67,7 @@
 #include "VocBase/LogicalCollection.h"
 #include "VocBase/LogicalView.h"
 #include "VocBase/ManagedDocumentResult.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "IResearch/VelocyPackHelper.h"
 #include "analysis/analyzers.hpp"
@@ -199,6 +200,9 @@ class IResearchQueryScorerTest : public ::testing::Test {
     TRI_vocbase_t* vocbase;
 
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
     analyzers->emplace(result, "testVocbase::test_analyzer", "TestAnalyzer",
                        VPackParser::fromJson("\"abc\"")->slice());  // cache analyzer
     analyzers->emplace(result, "testVocbase::test_csv_analyzer",

tests/IResearch/IResearchQueryTokens-test.cpp

@@ -62,6 +62,7 @@
 #include "VocBase/LogicalCollection.h"
 #include "VocBase/LogicalView.h"
 #include "VocBase/ManagedDocumentResult.h"
+#include "VocBase/Methods/Collections.h"
 
 #include "IResearch/VelocyPackHelper.h"
 #include "analysis/analyzers.hpp"
@@ -250,6 +251,9 @@ class IResearchQueryTokensTest : public ::testing::Test {
     TRI_vocbase_t* vocbase;
 
     dbFeature->createDatabase(1, "testVocbase", vocbase);  // required for IResearchAnalyzerFeature::emplace(...)
+    arangodb::methods::Collections::createSystem(
+        *vocbase,
+        arangodb::tests::AnalyzerCollectionName);
     analyzers->emplace(result, "testVocbase::test_analyzer", "TestAnalyzer",
                        VPackParser::fromJson("\"abc\"")->slice());  // cache analyzer
     analyzers->emplace(result, "testVocbase::test_csv_analyzer",

tests/IResearch/common.cpp

@@ -245,8 +245,11 @@ REGISTER_SCORER_JSON(CustomScorer, CustomScorer::make);
 }  // namespace
 
 namespace arangodb {
+
 namespace tests {
 
+std::string const AnalyzerCollectionName("_analyzers");
+
 std::string testResourceDir;
 
 static void findIResearchTestResources() {

tests/IResearch/common.h

@@ -62,6 +62,9 @@ class ByExpression;
 
 namespace tests {
 
+ extern std::string const AnalyzerCollectionName;
+
+
 extern std::string testResourceDir;
 
 void init(bool withICU = false);

tests/RestHandler/RestAnalyzerHandler-test.cpp

@@ -21,6 +21,7 @@
 /// @author Vasiliy Nabatchikov
 ////////////////////////////////////////////////////////////////////////////////
 
+#include "../IResearch/common.h"
 #include "gtest/gtest.h"
 
 #include "../IResearch/RestHandlerMock.h"
@@ -41,6 +42,7 @@
 #include "RestServer/SystemDatabaseFeature.h"
 #include "StorageEngine/EngineSelectorFeature.h"
 #include "V8Server/V8DealerFeature.h"
+#include "VocBase/Methods/Collections.h"
 #include "velocypack/Iterator.h"
 #include "velocypack/Parser.h"
 
@@ -178,6 +180,9 @@ TEST_F(RestAnalyzerHandlerTest, test_create) {
         arangodb::StaticStrings::SystemDatabase + "\" } ]");
     ASSERT_TRUE((TRI_ERROR_NO_ERROR == dbFeature->loadDatabases(databases->slice())));
     sysDatabase->start();  // get system database from DatabaseFeature
+    arangodb::methods::Collections::createSystem(
+        *sysDatabase->use(), 
+        arangodb::tests::AnalyzerCollectionName);
   }
 
   arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
@@ -618,6 +623,9 @@ TEST_F(RestAnalyzerHandlerTest, test_get) {
         std::string("[ { \"name\": \"") +
         arangodb::StaticStrings::SystemDatabase + "\" } ]");
     ASSERT_TRUE((TRI_ERROR_NO_ERROR == dbFeature->loadDatabases(databases->slice())));
+    arangodb::methods::Collections::createSystem(
+        *dbFeature->useDatabase(arangodb::StaticStrings::SystemDatabase),
+        arangodb::tests::AnalyzerCollectionName);
   }
 
   arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
@@ -990,6 +998,12 @@ TEST_F(RestAnalyzerHandlerTest, test_list) {
     ASSERT_TRUE((TRI_ERROR_NO_ERROR ==
                  dbFeature->createDatabase(1, "testVocbase", vocbase)));
     sysDatabase->start();  // get system database from DatabaseFeature
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
+    arangodb::methods::Collections::createSystem(
+        *sysDatabase->use(), 
+        arangodb::tests::AnalyzerCollectionName);
   }
 
   arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
@@ -1381,6 +1395,9 @@ TEST_F(RestAnalyzerHandlerTest, test_remove) {
         std::string("[ { \"name\": \"") +
         arangodb::StaticStrings::SystemDatabase + "\" } ]");
     ASSERT_TRUE((TRI_ERROR_NO_ERROR == dbFeature->loadDatabases(databases->slice())));
+    arangodb::methods::Collections::createSystem(
+        *dbFeature->useDatabase(arangodb::StaticStrings::SystemDatabase),
+        arangodb::tests::AnalyzerCollectionName);
   }
 
   arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;

tests/V8Server/v8-analyzers-test.cpp

@@ -42,6 +42,7 @@
 #include "RestServer/QueryRegistryFeature.h"
 #include "RestServer/SystemDatabaseFeature.h"
 #include "StorageEngine/EngineSelectorFeature.h"
+#include "VocBase/Methods/Collections.h"
 #include "Utils/ExecContext.h"
 #include "V8/v8-conv.h"
 #include "V8/v8-utils.h"
@@ -214,6 +215,12 @@ TEST_F(V8AnalyzersTest, test_accessors) {
         arangodb::StaticStrings::SystemDatabase + "\" } ]");
     ASSERT_TRUE((TRI_ERROR_NO_ERROR == dbFeature->loadDatabases(databases->slice())));
   }
+  {
+    auto vocbase = dbFeature->useDatabase(arangodb::StaticStrings::SystemDatabase);
+    arangodb::methods::Collections::createSystem(
+        *vocbase,
+        arangodb::tests::AnalyzerCollectionName);
+  }
 
   arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
   ASSERT_TRUE((analyzers
@@ -704,7 +711,12 @@ TEST_F(V8AnalyzersTest, test_create) {
     ASSERT_TRUE((TRI_ERROR_NO_ERROR == dbFeature->loadDatabases(databases->slice())));
     sysDatabase->start();  // get system database from DatabaseFeature
   }
-
+  {
+    auto vocbase = dbFeature->useDatabase(arangodb::StaticStrings::SystemDatabase);
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
+  }
   arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
 
   {
@@ -1283,7 +1295,12 @@ TEST_F(V8AnalyzersTest, test_get) {
         arangodb::StaticStrings::SystemDatabase + "\" } ]");
     ASSERT_TRUE((TRI_ERROR_NO_ERROR == dbFeature->loadDatabases(databases->slice())));
   }
-
+  {
+    auto vocbase = dbFeature->useDatabase(arangodb::StaticStrings::SystemDatabase);
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
+  }
   arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
   ASSERT_TRUE((analyzers
                    ->emplace(result, arangodb::StaticStrings::SystemDatabase + "::testAnalyzer1",
@@ -1818,8 +1835,17 @@ TEST_F(V8AnalyzersTest, test_list) {
     ASSERT_TRUE((TRI_ERROR_NO_ERROR ==
                  dbFeature->createDatabase(1, "testVocbase", vocbase)));
     sysDatabase->start();  // get system database from DatabaseFeature
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
   }
-
+  {
+    auto vocbase = dbFeature->useDatabase(arangodb::StaticStrings::SystemDatabase);
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
+  }
+      
   arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
   ASSERT_TRUE((analyzers
                    ->emplace(result, arangodb::StaticStrings::SystemDatabase + "::testAnalyzer1",
@@ -2271,7 +2297,12 @@ TEST_F(V8AnalyzersTest, test_remove) {
         arangodb::StaticStrings::SystemDatabase + "\" } ]");
     ASSERT_TRUE((TRI_ERROR_NO_ERROR == dbFeature->loadDatabases(databases->slice())));
   }
-
+  {
+    auto vocbase = dbFeature->useDatabase(arangodb::StaticStrings::SystemDatabase);
+    arangodb::methods::Collections::createSystem(
+        *vocbase, 
+        arangodb::tests::AnalyzerCollectionName);
+  }
   arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
   ASSERT_TRUE((analyzers
                    ->emplace(result, arangodb::StaticStrings::SystemDatabase + "::testAnalyzer1",

tests/js/common/aql/aql-view-arangosearch-feature.js

@@ -97,23 +97,38 @@ function iResearchFeatureAqlTestSuite () {
       assertTrue(Array === oldList.constructor);
 
       // creation
-      analyzers.save("testAnalyzer", "identity", {}, [ "frequency" ]);
+      analyzers.save("testAnalyzer", "stem", { "locale":"en"}, [ "frequency" ]);
 
       // properties
       let analyzer = analyzers.analyzer(db._name() + "::testAnalyzer");
       assertTrue(null !== analyzer);
       assertEqual(db._name() + "::testAnalyzer", analyzer.name());
-      assertEqual("identity", analyzer.type());
-      assertEqual(0, Object.keys(analyzer.properties()).length);
+      assertEqual("stem", analyzer.type());
+      assertEqual(1, Object.keys(analyzer.properties()).length);
+      assertEqual("en", analyzer.properties().locale);
       assertTrue(Array === analyzer.features().constructor);
       assertEqual(1, analyzer.features().length);
       assertEqual([ "frequency" ], analyzer.features());
-      analyzer = undefined; // release reference
+      analyzer = undefined; // release reference 
+
+      // check the analyzers collection in database
+      assertEqual(oldListInCollection.length + 1, db._analyzers.toArray().length);
+      let dbAnalyzer = db._query("FOR d in _analyzers FILTER d.name=='testAnalyzer' RETURN d").toArray();
+      assertEqual(1, dbAnalyzer.length);
+      assertEqual("testAnalyzer", dbAnalyzer[0].name);
+      assertEqual("stem", dbAnalyzer[0].type);
+      assertEqual(1, Object.keys(dbAnalyzer[0].properties).length);
+      assertEqual("en", dbAnalyzer[0].properties.locale);
+      assertTrue(Array === dbAnalyzer[0].features.constructor);
+      assertEqual(1, dbAnalyzer[0].features.length);
+      assertEqual([ "frequency" ], dbAnalyzer[0].features);
+      dbAnalyzer = undefined;
 
       // listing
       let list = analyzers.toArray();
       assertTrue(Array === list.constructor);
       assertEqual(oldList.length + 1, list.length);
+
       list = undefined; // release reference
 
       // force server-side V8 garbage collection