hce-node application  1.4.3
HCE Hierarchical Cluster Engine node application
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
SphinxAdminCommandTest.cpp
Go to the documentation of this file.
1 #include <gtest/gtest.h>
2 #include <iomanip>
3 #include <sstream>
4 #include <fstream>
5 #include <set>
6 
7 #include <Poco/SharedPtr.h>
8 #include "SphinxTestPrinter.hpp"
9 
10 #include "EncodeDecodeBase64.hpp"
11 #include "SphinxError.hpp"
12 #include "SphinxManageTest.hpp"
13 #include "SphinxInputJsonMessage.hpp"
14 #include "SphinxOutputJsonMessage.hpp"
15 #include "SphinxFunctionalObject.hpp"
16 #include "SphinxFunctionalObjectTest.hpp"
17 #include "SphinxPrintStatus.hpp"
18 
19 namespace HCE
20 {
21 namespace sphinx
22 {
23 namespace tests
24 {
25 extern std::string homeDir;
26 extern Poco::SharedPtr<HCE::sphinx::SphinxFunctionalObject> pObj;
27 
28 const std::string nodeName = "test_node";
29 const std::string defaultIndex = "i001";
30 const std::string indexName = "i003";
31 const std::string copyIndexName = "i004";
32 const std::string renameIndexName = "i005";
33 //-----------------------------------------------------------------------------
34 TEST(SphinxAdminCommand, notLoadConfigInConstructor)
35 {
36  HCE::sphinx::SphinxFunctionalObject fObject(nodeName, 234, homeDir);
37  ASSERT_FALSE(fObject.isLoadedConfig());
38  ASSERT_FALSE(fObject.isActiveSearchd());
39 }
40 //-----------------------------------------------------------------------------
41 TEST(SphinxAdminCommand, loadConfigInConstructor)
42 {
43  HCE::sphinx::SphinxFunctionalObject* pObj = new HCE::sphinx::SphinxFunctionalObject(nodeName, 234, homeDir);
44  ASSERT_NE(pObj, nullptr);
45 
46  SphinxManageTest::testIndexCreate(*pObj, defaultIndex);
47  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
48  delete pObj;
49 
50  HCE::sphinx::SphinxFunctionalObject* pObject = new HCE::sphinx::SphinxFunctionalObject(nodeName, 234, homeDir, defaultIndex, sphinx_search_const::searchdStart, sphinx_search_const::searchdStop);
51  ASSERT_NE(pObject, nullptr);
52  pObject->setLogStream(std::cout);
53  ASSERT_TRUE(pObject->isLoadedConfig());
54  ASSERT_TRUE(pObject->isActiveSearchd());
55  delete pObject;
56 
57  pObj = new HCE::sphinx::SphinxFunctionalObject("", 0, homeDir);
58  ASSERT_NE(pObj, nullptr);
59  SphinxManageTest::testIndexRemove(*pObj, defaultIndex);
60  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
61  delete pObj;
62 }
63 //-----------------------------------------------------------------------------
64 //-----------------------------------------------------------------------------
65 class SphinxAdminCommandTest : public ::testing::Test
66 {
67 protected:
68  static void SetUpTestCase(void)
69  {
70  pObj = Poco::SharedPtr<HCE::sphinx::SphinxFunctionalObject>(new HCE::sphinx::SphinxFunctionalObject(nodeName, 234, homeDir));
71 // pObj->setLogStream(std::cout);
72  }
73  // cppcheck-suppress unusedFunction
74  static void TearDownTestCase(void)
75  {
76  pObj = nullptr;
77  }
78 };
79 
80 std::vector<std::string> branches;
81 //-----------------------------------------------------------------------------
82 //-----------------------------------------------------------------------------
83 TEST_F(SphinxAdminCommandTest, isCreatedSphinxFunctionalObject)
84 {
85  ASSERT_FALSE(pObj.isNull());
86 }
87 //-----------------------------------------------------------------------------
88 TEST_F(SphinxAdminCommandTest, isActiveSearchd)
89 {
90  ASSERT_FALSE(pObj->isActiveSearchd());
91 }
92 //-----------------------------------------------------------------------------
93 TEST_F(SphinxAdminCommandTest, isNotLoadedConfig)
94 {
95  ASSERT_FALSE(pObj->isLoadedConfig());
96 }
97 //-----------------------------------------------------------------------------
98 TEST_F(SphinxAdminCommandTest, testIndexCreateRemove)
99 {
100  SphinxManageTest::testIndexCreate(*pObj, indexName);
101  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
102  SphinxManageTest::testIndexRemove(*pObj, indexName);
103  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
104 }
105 //-----------------------------------------------------------------------------
106 //-----------------------------------------------------------------------------
107 TEST_F(SphinxAdminCommandTest, testIndexCheckExist)
108 {
109  SphinxManageTest::testIndexCreate(*pObj, indexName);
110  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
111  SphinxManageTest::testIndexCheck(*pObj, indexName, true);
112  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CHECK_INDEX) << printError(*pObj);
113  SphinxManageTest::testIndexRemove(*pObj, indexName);
114  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
115 }
116 //-----------------------------------------------------------------------------
117 //-----------------------------------------------------------------------------
118 TEST_F(SphinxAdminCommandTest, testIndexCheckNotExist)
119 {
120  SphinxManageTest::testIndexCheck(*pObj, "branch_0006", false);
121  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CHECK_INDEX) << printError(*pObj);
122 }
123 //-----------------------------------------------------------------------------
124 //-----------------------------------------------------------------------------
125 TEST_F(SphinxAdminCommandTest, testIndexStoreDataFile)
126 {
127  SphinxManageTest::testIndexCreate(*pObj, indexName);
128  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
129  branches.clear();
130  branches.push_back("branch_0005");
131  branches.push_back("branch_0006");
132  branches.push_back("branch_0007");
133  for (size_t i=0;i<branches.size();++i)
134  {
135  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i], "");
136  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
137  }
138  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
139  SphinxManageTest::testIndexRemove(*pObj, indexName);
140  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
141 }
142 //-----------------------------------------------------------------------------
143 //-----------------------------------------------------------------------------
144 TEST_F(SphinxAdminCommandTest, testIndexStoreSchemaFile)
145 {
146  SphinxManageTest::testIndexCreate(*pObj, indexName);
147  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
148  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName, "");
149  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
150  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
151  SphinxManageTest::testIndexRemove(*pObj, indexName);
152  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
153 }
154 //-----------------------------------------------------------------------------
155 //-----------------------------------------------------------------------------
156 TEST_F(SphinxAdminCommandTest, testIndexMaxDocId)
157 {
158  SphinxManageTest::testIndexCreate(*pObj, indexName);
159  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
160  branches.clear();
161  branches.push_back("branch_0005");
162  for (size_t i=0;i<branches.size();++i)
163  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
164  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
165  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
166  SphinxManageTest::testIndexMaxDocId(*pObj, indexName);
167  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
168  SphinxManageTest::testIndexRemove(*pObj, indexName);
169  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
170 }
171 //-----------------------------------------------------------------------------
172 //-----------------------------------------------------------------------------
173 TEST_F(SphinxAdminCommandTest, testIndexMaxDocIdExtended)
174 {
175  SphinxManageTest::testIndexCreate(*pObj, indexName);
176  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
177  branches.clear();
178  branches.push_back("branch_0005");
179  branches.push_back("branch_0006");
180  for (size_t i=0;i<branches.size();++i)
181  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
182  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
183  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
184  SphinxManageTest::testIndexMaxDocIdExtended(*pObj, indexName);
185  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
186  SphinxManageTest::testIndexRemove(*pObj, indexName);
187  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
188 }
189 //-----------------------------------------------------------------------------
190 //-----------------------------------------------------------------------------
191 TEST_F(SphinxAdminCommandTest, testIndexRebuild)
192 {
193  SphinxManageTest::testIndexCreate(*pObj, indexName);
194  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
195  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
196  branches.clear();
197  branches.push_back("branch_0005");
198  branches.push_back("branch_0006");
199  branches.push_back("branch_0007");
200  for (size_t i=0;i<branches.size();++i)
201  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
202  branches.push_back("branch_0008");
203  branches.push_back("branch_0009");
204  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
205 
206  branches.clear();
207  branches.push_back("*");
208  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
209  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
210  SphinxManageTest::testIndexRemove(*pObj, indexName);
211  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
212 }
213 //-----------------------------------------------------------------------------
214 //-----------------------------------------------------------------------------
215 TEST_F(SphinxAdminCommandTest, testIndexMergeStart)
216 {
217  SphinxManageTest::testIndexCreate(*pObj, indexName);
218  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
219  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
220  branches.clear();
221  branches.push_back("branch_0005");
222  branches.push_back("branch_0006");
223  branches.push_back("branch_0007");
224  for (size_t i=0;i<branches.size();++i)
225  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
226  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
227  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
228  SphinxManageTest::testIndexStart(*pObj, indexName);
229  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
230  SphinxManageTest::testIndexRemove(*pObj, indexName);
231  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
232 }
233 //-----------------------------------------------------------------------------
234 //-----------------------------------------------------------------------------
235 TEST_F(SphinxAdminCommandTest, testIndexDeleteDataFile)
236 {
237  SphinxManageTest::testIndexCreate(*pObj, indexName);
238  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
239  branches.clear();
240  branches.push_back("branch_0005");
241  for (size_t i=0;i<branches.size();++i)
242  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
243  SphinxManageTest::testIndexDeleteDataFile(*pObj, indexName, branches);
244  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
245  SphinxManageTest::testIndexRemove(*pObj, indexName);
246  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
247 }
248 //-----------------------------------------------------------------------------
249 //-----------------------------------------------------------------------------
250 TEST_F(SphinxAdminCommandTest, testIndexRebuildMergeStart)
251 {
252  SphinxManageTest::testIndexCreate(*pObj, indexName);
253  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
254  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
255  branches.clear();
256  branches.push_back("branch_0005");
257  branches.push_back("branch_0006");
258  branches.push_back("branch_0007");
259  for (size_t i=0;i<branches.size();++i)
260  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
261  branches.clear();
262  branches.push_back("*");
263  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
264  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
265  SphinxManageTest::testIndexStart(*pObj, indexName);
266  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
267  SphinxManageTest::testIndexRemove(*pObj, indexName);
268  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
269 }
270 //-----------------------------------------------------------------------------
271 //-----------------------------------------------------------------------------
272 TEST_F(SphinxAdminCommandTest, testIndexMergeNotExist)
273 {
274  SphinxManageTest::testIndexCreate(*pObj, indexName);
275  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
276  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
277  branches.clear();
278  branches.push_back("branch_0005");
279  branches.push_back("branch_0006");
280  branches.push_back("branch_0007");
281  for (size_t i=0;i<branches.size();++i)
282  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
283  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
284  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
285  branches.push_back("branch_0008"); // not exists
286  branches.push_back("branch_0009"); // not exists
287  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
288  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
289  SphinxManageTest::testIndexRemove(*pObj, indexName);
290  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
291 }
292 //-----------------------------------------------------------------------------
293 //-----------------------------------------------------------------------------
294 TEST_F(SphinxAdminCommandTest, testIndexStartStopStart)
295 {
296  SphinxManageTest::testIndexCreate(*pObj, indexName);
297  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
298  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
299  branches.clear();
300  branches.push_back("branch_0005");
301  for (size_t i=0;i<branches.size();++i)
302  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
303  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
304  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
305  SphinxManageTest::testIndexStart(*pObj, indexName);
306  SphinxManageTest::testIndexStop(*pObj, indexName);
307  SphinxManageTest::testIndexStart(*pObj, indexName);
308  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
309  SphinxManageTest::testIndexRemove(*pObj, indexName);
310  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
311 }
312 //-----------------------------------------------------------------------------
313 TEST_F(SphinxAdminCommandTest, testIndexDeleteDataFileAndDeleteSchemaFile)
314 {
315  SphinxManageTest::testIndexCreate(*pObj, indexName);
316  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
317  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
318  branches.clear();
319  branches.push_back("branch_0005");
320  branches.push_back("branch_0006");
321  branches.push_back("branch_0007");
322  for (size_t i=0;i<branches.size();++i)
323  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
324  SphinxManageTest::testIndexDeleteDataFile(*pObj, indexName, branches);
325  for (size_t i=0;i<branches.size();++i)
326  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
327  branches.clear();
328  branches.push_back("*");
329  SphinxManageTest::testIndexDeleteDataFile(*pObj, indexName, branches);
330  SphinxManageTest::testIndexDeleteSchemaFile(*pObj, indexName);
331  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
332  SphinxManageTest::testIndexRemove(*pObj, indexName);
333  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
334 }
335 //-----------------------------------------------------------------------------
336 //-----------------------------------------------------------------------------
337 TEST_F(SphinxAdminCommandTest, testIndexAppendDataFile)
338 {
339  SphinxManageTest::testIndexCreate(*pObj, indexName);
340  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
341  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
342  branches.clear();
343  branches.push_back("branch_0005");
344  branches.push_back("branch_0006");
345  branches.push_back("branch_0007");
346  for (size_t i=0;i<branches.size();++i)
347  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
348  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
349  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
350  SphinxManageTest::testIndexStart(*pObj, indexName);
351  branches.clear();
352  branches.push_back("branch_0005");
353  branches.push_back("branch_0006");
354  for (size_t i=0;i<branches.size();++i)
355  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
356  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
357  for (size_t i=0;i<branches.size();++i)
358  SphinxManageTest::testIndexAppendDataFile(*pObj, indexName, branches[i]);
359  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
360  SphinxManageTest::testIndexRemove(*pObj, indexName);
361  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
362 }
363 //-----------------------------------------------------------------------------
364 //-----------------------------------------------------------------------------
365 TEST_F(SphinxAdminCommandTest, testIndexDeleteDoc)
366 {
367  SphinxManageTest::testIndexCreate(*pObj, indexName);
368  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
369  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
370  branches.clear();
371  branches.push_back("branch_0005");
372  branches.push_back("branch_0006");
373  branches.push_back("branch_0007");
374  for (size_t i=0;i<branches.size();++i)
375  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
376  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
377  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
378 
379  std::vector<unsigned long long> ids = { 123456789012, 123456789023, 123456789034, 123456789045, 123456789056, 123456789067, 123456789078, 123456789089, 123456789090, 1234567890101};
380  SphinxManageTest::testIndexDeleteDoc(*pObj, indexName, ids);
381  SphinxManageTest::testIndexDeleteDocNumber(*pObj, indexName);
382  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
383  SphinxManageTest::testIndexRemove(*pObj, indexName);
384  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
385 }
386 //-----------------------------------------------------------------------------
387 //-----------------------------------------------------------------------------
388 TEST_F(SphinxAdminCommandTest, testIndexPackDocData)
389 {
390  SphinxManageTest::testIndexCreate(*pObj, indexName);
391  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
392  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
393  branches.clear();
394  branches.push_back("branch_0005");
395  branches.push_back("branch_0006");
396  branches.push_back("branch_0007");
397  for (size_t i=0;i<branches.size();++i)
398  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
399 
400  SphinxManageTest::testIndexDeleteDocNumber(*pObj, indexName);
401  SphinxManageTest::testIndexPackDocData(*pObj, indexName, branches);
402 
403  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
404  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
405  branches.clear();
406  branches.push_back("*");
407  SphinxManageTest::testIndexPackDocData(*pObj, indexName, branches);
408  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
409  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
410  SphinxManageTest::testIndexRemove(*pObj, indexName);
411  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
412 }
413 //-----------------------------------------------------------------------------
414 //-----------------------------------------------------------------------------
415 TEST_F(SphinxAdminCommandTest, testIndexRemove)
416 {
417  SphinxManageTest::testIndexCreate(*pObj, indexName);
418  ASSERT_TRUE(pObj->getErrorCode()==NO_ERROR || pObj->getErrorCode()==ERROR_CREATE_INDEX) << printError(*pObj);
419  SphinxManageTest::testIndexRemove(*pObj, indexName);
420  SphinxManageTest::testIndexCheck(*pObj, indexName, false);
421  ASSERT_TRUE(pObj->isError());
422 }
423 //-----------------------------------------------------------------------------
424 //-----------------------------------------------------------------------------
425 TEST_F(SphinxAdminCommandTest, testIndexCopy)
426 {
427  // prepare for next copy index
428  SphinxManageTest::testIndexCreate(*pObj, indexName);
429  SphinxManageTest::testIndexCheck(*pObj, indexName, true);
430  branches.clear();
431  branches.push_back("branch_0005");
432  branches.push_back("branch_0006");
433  branches.push_back("branch_0007");
434  for (size_t i=0;i<branches.size();++i)
435  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
436  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
437  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
438  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
439  // make copy index
440  SphinxManageTest::testIndexStart(*pObj, indexName);
441  SphinxManageTest::testIndexStop(*pObj, indexName);
442  SphinxManageTest::testIndexStart(*pObj, indexName);
443  SphinxManageTest::testIndexCopy(*pObj, indexName, copyIndexName);
444  SphinxManageTest::testIndexCheck(*pObj, copyIndexName, true);
445  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
446  SphinxManageTest::testIndexRemove(*pObj, indexName);
447  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
448  SphinxManageTest::testIndexRemove(*pObj, copyIndexName);
449  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
450 }
451 //-----------------------------------------------------------------------------
452 //-----------------------------------------------------------------------------
453 TEST_F(SphinxAdminCommandTest, testIndexRename)
454 {
455  // prepare for next copy index
456  SphinxManageTest::testIndexCreate(*pObj, indexName);
457  SphinxManageTest::testIndexCheck(*pObj, indexName, true);
458  branches.clear();
459  branches.push_back("branch_0005");
460  branches.push_back("branch_0006");
461  branches.push_back("branch_0007");
462  for (size_t i=0;i<branches.size();++i)
463  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
464  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
465  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
466  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
467  SphinxManageTest::testIndexStart(*pObj, indexName);
468 
469  // make rename index
470  SphinxManageTest::testIndexRename(*pObj, indexName, renameIndexName);
471  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
472  SphinxManageTest::testIndexCheck(*pObj, indexName, false);
473  pObj->resetError();
474  SphinxManageTest::testIndexCheck(*pObj, renameIndexName, true);
475  SphinxManageTest::testIndexRemove(*pObj, renameIndexName);
476  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
477 }
478 //-----------------------------------------------------------------------------
479 //-----------------------------------------------------------------------------
480 TEST_F(SphinxAdminCommandTest, testIndexSetConfigVarGetConfigVar)
481 {
482  std::cout << "HOME DIR: " << pObj->getHomeDir() << std::endl;
483 
484  SphinxManageTest::testIndexCreate(*pObj, renameIndexName);
485  SphinxManageTest::testIndexCheck(*pObj, renameIndexName, true);
486  branches.clear();
487  branches.push_back("branch_0005");
488  branches.push_back("branch_0006");
489  branches.push_back("branch_0007");
490  for (size_t i=0;i<branches.size();++i)
491  SphinxManageTest::testIndexStoreDataFile(*pObj, renameIndexName, branches[i]);
492  SphinxManageTest::testIndexStoreSchemaFile(*pObj, renameIndexName);
493  SphinxManageTest::testIndexRebuild(*pObj, renameIndexName, branches);
494  SphinxManageTest::testIndexMerge(*pObj, renameIndexName, branches);
495 
496  SphinxManageTest::testIndexStart(*pObj, renameIndexName);
497  // make remove index
498  SphinxManageTest::testIndexRemove(*pObj, renameIndexName);
499  SphinxManageTest::testIndexCheck(*pObj, renameIndexName, false);
500 
501  SphinxManageTest::testIndexCreate(*pObj, indexName);
502  branches.clear();
503  branches.push_back("branch_0005");
504  for (size_t i=0;i<branches.size();++i)
505  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
506  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
507  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
508  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
509 
510  // set config property value
511  SphinxManageTest::testIndexSetConfigVar(*pObj, indexName, "", "searchd", "test_param", "test_value1");
512  SphinxManageTest::testIndexSetConfigVar(*pObj, indexName, "", "index branch_0001", "test_param", "test_value2");
513  SphinxManageTest::testIndexSetConfigVar(*pObj, indexName, "branch_0005", "searchd", "test_param", "test_value1");
514  SphinxManageTest::testIndexSetConfigVar(*pObj, indexName, "branch_0005", "index branch_0001", "test_param", "test_value2");
515  // get config property value
516  std::string paramValue;
517  SphinxManageTest::testIndexGetConfigVar(*pObj, indexName, "", "searchd", "test_param", paramValue);
518  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
519  ASSERT_EQ(paramValue, "test_value1");
520  SphinxManageTest::testIndexGetConfigVar(*pObj, indexName, "", "index branch_0001", "test_param", paramValue);
521  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
522  ASSERT_EQ(paramValue, "test_value2");
523  SphinxManageTest::testIndexGetConfigVar(*pObj, indexName, "branch_0005", "searchd", "test_param", paramValue);
524  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
525  ASSERT_EQ(paramValue, "test_value1");
526  SphinxManageTest::testIndexGetConfigVar(*pObj, indexName, "branch_0005", "index branch_0001", "test_param", paramValue);
527  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
528  ASSERT_EQ(paramValue, "test_value2");
529  // check validation of schema data and save in index if valid
530  SphinxManageTest::testIndexDeleteSchemaFile(*pObj, indexName);
531 
532  SphinxManageTest::testIndexRemove(*pObj, indexName);
533  SphinxManageTest::testIndexCreate(*pObj, indexName);
534  branches.clear();
535  branches.push_back("branch_0005");
536  for (size_t i=0;i<branches.size();++i)
537  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
538  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
539  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
540  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
541  SphinxManageTest::testIndexStart(*pObj, indexName);
542  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
543  SphinxManageTest::testIndexRemove(*pObj, indexName);
544  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
545 }
546 //-----------------------------------------------------------------------------
547 //-----------------------------------------------------------------------------
548 TEST_F(SphinxAdminCommandTest, testIndexCheckSchema)
549 {
550  SphinxManageTest::testIndexCreate(*pObj, indexName);
551  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
552  SphinxManageTest::testIndexCheckSchema(*pObj, indexName);
553  ASSERT_FALSE(pObj->isError());
554  SphinxManageTest::testIndexRemove(*pObj, indexName);
555  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
556 }
557 //-----------------------------------------------------------------------------
558 //-----------------------------------------------------------------------------
559 TEST_F(SphinxAdminCommandTest, testIndexStatusSearchd)
560 {
561  SphinxManageTest::testIndexCreate(*pObj, indexName);
562  SphinxManageTest::testIndexCheck(*pObj, indexName, true);
563  branches.clear();
564  branches.push_back("branch_0005");
565  for (size_t i=0;i<branches.size();++i)
566  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
567  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
568  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
569  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
570  // make copy index
571  SphinxManageTest::testIndexStart(*pObj, indexName);
572  SphinxManageTest::testIndexStatusSearchd(*pObj, indexName);
573  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
574  SphinxManageTest::testIndexRemove(*pObj, indexName);
575  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
576 }
577 //-----------------------------------------------------------------------------
578 //-----------------------------------------------------------------------------
579 TEST_F(SphinxAdminCommandTest, testIndexStatus)
580 {
581  SphinxManageTest::testIndexCreate(*pObj, indexName);
582  SphinxManageTest::testIndexCheck(*pObj, indexName, true);
583  branches.clear();
584  branches.push_back("branch_0005");
585  for (size_t i=0;i<branches.size();++i)
586  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
587  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
588  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
589  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
590  // make copy index
591  SphinxManageTest::testIndexStart(*pObj, indexName);
592  SphinxManageTest::testIndexStatus(*pObj, indexName);
593  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
594  SphinxManageTest::testIndexRemove(*pObj, indexName);
595  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
596 }
597 //-----------------------------------------------------------------------------
598 //-----------------------------------------------------------------------------
599 TEST_F(SphinxAdminCommandTest, testIndexDataList)
600 {
601  SphinxManageTest::testIndexCreate(*pObj, indexName);
602  SphinxManageTest::testIndexCheck(*pObj, indexName, true);
603  branches.clear();
604  branches.push_back("branch_0005");
605  for (size_t i=0;i<branches.size();++i)
606  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
607  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
608  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
609  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
610  // make copy index
611  SphinxManageTest::testIndexStart(*pObj, indexName);
612  SphinxManageTest::testIndexDataList(*pObj, indexName);
613  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
614  SphinxManageTest::testIndexRemove(*pObj, indexName);
615  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
616 }
617 //-----------------------------------------------------------------------------
618 //-----------------------------------------------------------------------------
619 TEST_F(SphinxAdminCommandTest, testIndexBranchesList)
620 {
621  SphinxManageTest::testIndexCreate(*pObj, indexName);
622  SphinxManageTest::testIndexCheck(*pObj, indexName, true);
623  branches.clear();
624  branches.push_back("branch_0005");
625  for (size_t i=0;i<branches.size();++i)
626  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
627  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
628  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
629  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
630  // make copy index
631  SphinxManageTest::testIndexStart(*pObj, indexName);
632  SphinxManageTest::testIndexBranchesList(*pObj, indexName);
633  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
634  SphinxManageTest::testIndexRemove(*pObj, indexName);
635  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
636 }
637 //-----------------------------------------------------------------------------
638 //-----------------------------------------------------------------------------
639 TEST_F(SphinxAdminCommandTest, testIndexBranchesInfo)
640 {
641  SphinxManageTest::testIndexCreate(*pObj, indexName);
642  SphinxManageTest::testIndexCheck(*pObj, indexName, true);
643  branches.clear();
644  branches.push_back("branch_0005");
645  for (size_t i=0;i<branches.size();++i)
646  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
647  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
648  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
649  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
650  // make copy index
651  SphinxManageTest::testIndexStart(*pObj, indexName);
652  SphinxManageTest::testIndexBranchesInfo(*pObj, indexName, branches);
653  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
654  SphinxManageTest::testIndexRemove(*pObj, indexName);
655  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
656 }
657 //-----------------------------------------------------------------------------
658 //-----------------------------------------------------------------------------
659 TEST_F(SphinxAdminCommandTest, testIndexBranchesStatus)
660 {
661  SphinxManageTest::testIndexCreate(*pObj, indexName);
662  SphinxManageTest::testIndexCheck(*pObj, indexName, true);
663  branches.clear();
664  branches.push_back("branch_0005");
665  for (size_t i=0;i<branches.size();++i)
666  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
667  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
668  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
669  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
670  SphinxManageTest::testIndexStart(*pObj, indexName);
671  SphinxManageTest::testIndexBranchesStatus(*pObj, indexName, branches);
672  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
673  SphinxManageTest::testIndexRemove(*pObj, indexName);
674  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
675 }
676 //-----------------------------------------------------------------------------
677 //-----------------------------------------------------------------------------
678 TEST_F(SphinxAdminCommandTest, testIndexConnectDisconnect)
679 {
680  SphinxManageTest::testIndexCreate(*pObj, indexName);
681  SphinxManageTest::testIndexCheck(*pObj, indexName, true);
682  branches.clear();
683  branches.push_back("branch_0005");
684  for (size_t i=0;i<branches.size();++i)
685  SphinxManageTest::testIndexStoreDataFile(*pObj, indexName, branches[i]);
686  SphinxManageTest::testIndexStoreSchemaFile(*pObj, indexName);
687  SphinxManageTest::testIndexRebuild(*pObj, indexName, branches);
688  SphinxManageTest::testIndexMerge(*pObj, indexName, branches);
689  SphinxManageTest::testIndexStart(*pObj, indexName);
690  SphinxManageTest::testIndexDisconnect(*pObj);
691  SphinxManageTest::testIndexConnect(*pObj, indexName);
692  SphinxManageTest::testIndexRemove(*pObj, indexName);
693  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
694  SphinxManageTest::testIndexCheck(*pObj, indexName, false);
695  ASSERT_TRUE(pObj->isError());
696 }
697 //-----------------------------------------------------------------------------
698 //-----------------------------------------------------------------------------
699 TEST_F(SphinxAdminCommandTest, fullAdminCommandsTest)
700 {
701  SphinxFunctionalObjectTest::fullAdminCommandsTest(*pObj);
702  ASSERT_FALSE(pObj->isError()) << printError(*pObj);
703 }
704 //-----------------------------------------------------------------------------
705 //-----------------------------------------------------------------------------
706 } // end namespace tests
707 } // end namespace sphinx
708 } // end namespace HCE
709 
710 
711