func TestConcurrentScans_MultipleIndexes(t *testing.T) {
log.Printf("In TestConcurrentScans_MultipleIndexes()")
var wg sync.WaitGroup
prodfile = filepath.Join(proddir, "test.prod")
// secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
log.Printf("Generating JSON docs")
kvdocs = GenerateJsons(100000, seed, prodfile, bagdir)
seed++
log.Printf("Setting initial JSON docs in KV")
kv.SetKeyValues(kvdocs, "default", "", clusterconfig.KVAddress)
var index1 = "index_company"
var index2 = "index_age"
var index3 = "index_firstname"
var bucketName = "default"
log.Printf("Creating multiple indexes")
err := secondaryindex.CreateSecondaryIndex(index1, bucketName, indexManagementAddress, "", []string{"company"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
err = secondaryindex.CreateSecondaryIndex(index2, bucketName, indexManagementAddress, "", []string{"age"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
err = secondaryindex.CreateSecondaryIndex(index3, bucketName, indexManagementAddress, "", []string{"`first-name`"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
wg.Add(3)
go RangeScanForDuration_ltr("Thread 1: ", &wg, 120, t, index1, bucketName, indexScanAddress)
go RangeScanForDuration_num("Thread 2: ", &wg, 120, t, index2, bucketName, indexScanAddress)
go RangeScanForDuration_ltr("Thread 3: ", &wg, 120, t, index3, bucketName, indexScanAddress)
wg.Wait()
}
func TestCreate2Drop1Scan2(t *testing.T) {
log.Printf("In TestCreate2Drop1Scan2()")
var index1 = "index_i1"
var index2 = "index_i2"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndex(index1, bucketName, indexManagementAddress, "", []string{"company"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
err = secondaryindex.CreateSecondaryIndex(index2, bucketName, indexManagementAddress, "", []string{"age"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanResponse_string(docs, "company", "FI", "SR", 1)
scanResults, err := secondaryindex.Range(index1, bucketName, indexScanAddress, []interface{}{"FI"}, []interface{}{"SR"}, 1, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan 1", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
docScanResults = datautility.ExpectedScanResponse_float64(docs, "age", 30, 50, 1)
scanResults, err = secondaryindex.Range(index2, bucketName, indexScanAddress, []interface{}{30}, []interface{}{50}, 1, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan 2", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
err = secondaryindex.DropSecondaryIndex(index1, bucketName, indexManagementAddress)
docScanResults = datautility.ExpectedScanResponse_float64(docs, "age", 0, 60, 1)
scanResults, err = secondaryindex.Range(index2, bucketName, indexScanAddress, []interface{}{0}, []interface{}{60}, 1, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan 2", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
}
func TestIndexNameValidation(t *testing.T) {
log.Printf("In TestIndexNameValidation()")
var bucketName = "default"
var validIndexName = "#primary-Index_test"
var invalidIndexName = "ÌñÐÉx&(abc_%"
var field = "balance"
docsToCreate := generateDocs(1000, "users.prod")
UpdateKVDocs(docsToCreate, docs)
seed++
log.Printf("Setting JSON docs in KV")
kvutility.SetKeyValues(docsToCreate, "default", "", clusterconfig.KVAddress)
err := secondaryindex.CreateSecondaryIndex(invalidIndexName, bucketName, indexManagementAddress, "", []string{field}, false, nil, true, defaultIndexActiveTimeout, nil)
errMsg := "Expected index name validation error for index " + invalidIndexName
FailTestIfNoError(err, errMsg, t)
log.Printf("Creation of index with invalid name %v failed as expected", invalidIndexName)
err = secondaryindex.CreateSecondaryIndex(validIndexName, bucketName, indexManagementAddress, "", []string{field}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanResponse_string(docs, field, "$4", "$7", 3)
scanResults, err := secondaryindex.Range(validIndexName, bucketName, indexScanAddress, []interface{}{"$4"}, []interface{}{"$7"}, 3, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
}
// Test with large number of mutations
func TestLargeMutations(t *testing.T) {
log.Printf("In TestLargeMutations()")
var index1 = "indexmut_1"
var index2 = "indexmut_2"
var bucketName = "default"
var field1 = "company"
var field2 = "gender"
e := secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
FailTestIfError(e, "Error in DropAllSecondaryIndexes", t)
docsToCreate := generateDocs(20000, "users.prod")
UpdateKVDocs(docsToCreate, docs)
kv.SetKeyValues(docsToCreate, "default", "", clusterconfig.KVAddress)
err := secondaryindex.CreateSecondaryIndex(index1, bucketName, indexManagementAddress, "", []string{field1}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanAllResponse(docs, field1)
scanResults, err := secondaryindex.ScanAll(index1, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
log.Printf("Len of expected and actual scan results are : %d and %d", len(docScanResults), len(scanResults))
for i := 0; i <= 10; i++ {
log.Printf("ITERATION %v\n", i)
docsToCreate = generateDocs(10000, "users.prod")
UpdateKVDocs(docsToCreate, docs)
kv.SetKeyValues(docsToCreate, "default", "", clusterconfig.KVAddress)
err := secondaryindex.CreateSecondaryIndex(index2, bucketName, indexManagementAddress, "", []string{field2}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults = datautility.ExpectedScanAllResponse(docs, field1)
scanResults, err = secondaryindex.ScanAll(index1, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
log.Printf("Len of expected and actual scan results are : %d and %d", len(docScanResults), len(scanResults))
docScanResults = datautility.ExpectedScanAllResponse(docs, field2)
scanResults, err = secondaryindex.ScanAll(index2, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
log.Printf("Len of expected and actual scan results are : %d and %d", len(docScanResults), len(scanResults))
err = secondaryindex.DropSecondaryIndex(index2, bucketName, indexManagementAddress)
FailTestIfError(err, "Error in drop index", t)
}
}
func TestCreateDuplicateIndex(t *testing.T) {
log.Printf("In TestCreateDuplicateIndex()")
var index1 = "index_di1"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndex(index1, bucketName, indexManagementAddress, "", []string{"age"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
err = secondaryindex.CreateSecondaryIndex(index1, bucketName, indexManagementAddress, "", []string{"age"}, false, nil, false, defaultIndexActiveTimeout, nil)
if err == nil {
t.Fatal("Error excpected creating dupliate index but create didnt fail \n")
} else {
log.Printf("Create failed as expected with error: %v\n", err)
}
}
func TestCreateDropCreate(t *testing.T) {
log.Printf("In TestCreateDropCreate()")
var indexName = "index_cdc"
var bucketName = "default"
// Create an index
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"company"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
// Scan after index create
docScanResults := datautility.ExpectedScanResponse_string(docs, "company", "FI", "SR", 2)
scanResults, err := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"FI"}, []interface{}{"SR"}, 2, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan 1: ", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan 1 result validation: ", t)
// Drop the created index
err = secondaryindex.DropSecondaryIndex(indexName, bucketName, indexManagementAddress)
// Scan after dropping the index. Error expected
docScanResults = datautility.ExpectedScanResponse_string(docs, "company", "BIOSPAN", "ZILLANET", 0)
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"BIOSPAN"}, []interface{}{"ZILLANET"}, 0, true, defaultlimit, c.SessionConsistency, nil)
if err == nil {
t.Fatal("Scan 2: Error excpected when scanning for dropped index but scan didnt fail \n")
} else {
log.Printf("Scan 2 failed as expected with error: %v\n", err)
}
// Create the same index again
err = secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"company"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
// Scan the created index with inclusion 1
docScanResults = datautility.ExpectedScanResponse_string(docs, "company", "FI", "SR", 1)
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"FI"}, []interface{}{"SR"}, 1, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan 3: ", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan 3 result validation: ", t)
log.Printf("(Inclusion 1) Lengths of expected and actual scan results are %d and %d. Num of docs in bucket = %d", len(docScanResults), len(scanResults), len(docs))
// Scan the created index with inclusion 3
docScanResults = datautility.ExpectedScanResponse_string(docs, "company", "FI", "SR", 3)
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"FI"}, []interface{}{"SR"}, 3, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan 4: ", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan 4 result validation: ", t)
log.Printf("(Inclusion 3) Lengths of expected and actual scan results are %d and %d. Num of docs in bucket = %d", len(docScanResults), len(scanResults), len(docs))
}
// Test with mutations delay wait of 15s
func TestUpdateDocsMutation(t *testing.T) {
log.Printf("In TestUpdateDocsMutation()")
var indexName = "index_age"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"age"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanResponse_float64(docs, "age", 20, 40, 2)
scanResults, err := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{20}, []interface{}{40}, 2, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
log.Printf("Len of expected and actual scan results are : %d and %d", len(docScanResults), len(scanResults))
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
//Update docs mutations: Update docs in KV
UpdateDocs(100)
docScanResults = datautility.ExpectedScanResponse_float64(docs, "age", 20, 40, 2)
start := time.Now()
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{20}, []interface{}{40}, 2, true, defaultlimit, c.SessionConsistency, nil)
elapsed := time.Since(start)
log.Printf("Index Scan after mutations took %s\n", elapsed)
FailTestIfError(err, "Error in scan", t)
log.Printf("Len of expected and actual scan results are : %d and %d", len(docScanResults), len(scanResults))
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
}
func SkipTestPerfRangeWithoutMutations_1M(t *testing.T) {
log.Printf("In TestPerfQueryWithoutMutations_1M()")
e := secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
FailTestIfError(e, "Error in DropAllSecondaryIndexes", t)
prodfile := "../../../../../prataprc/monster/prods/test.prod"
bagdir := "../../../../../prataprc/monster/bags/"
log.Printf("Generating JSON docs")
count := 1000000
keyValues := GenerateJsons(count, 1, prodfile, bagdir)
log.Printf("Setting JSON docs in KV")
kv.SetKeyValues(keyValues, "default", "", clusterconfig.KVAddress)
var indexName = "index_company"
var bucketName = "default"
log.Printf("Creating a 2i")
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"company"}, false, nil, true, 1500, nil)
FailTestIfError(err, "Error in creating the index", t)
start := time.Now()
scanResults, err := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"E"}, []interface{}{"N"}, 3, true, defaultlimit, c.AnyConsistency, nil)
elapsed := time.Since(start)
log.Printf("RangeScan:: Len of scanResults is: %d", len(scanResults))
log.Printf("Range Scan of %d user documents took %s\n", count, elapsed)
}
func SkipTestPerfPrimaryIndexBuild_SimpleJson(t *testing.T) {
log.Printf("In TestPerfInitialIndexBuild()")
e := secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
FailTestIfError(e, "Error in DropAllSecondaryIndexes", t)
prodfile = filepath.Join(proddir, "test.prod")
log.Printf("Generating JSON docs")
count := 100000000
keyValues := GenerateJsons(count, 1, prodfile, bagdir)
log.Printf("Setting JSON docs in KV")
kv.SetKeyValues(keyValues, "default", "", clusterconfig.KVAddress)
var indexName = "index_primary"
var bucketName = "default"
log.Printf("Creating a 2i")
start := time.Now()
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", nil, true, nil, true, 1500, nil)
FailTestIfError(err, "Error in creating the index", t)
elapsed := time.Since(start)
log.Printf("Index build of %d user documents took %s\n", count, elapsed)
scanResults, err := secondaryindex.ScanAll(indexName, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
if len(scanResults) != len(keyValues) {
log.Printf("Len of scanResults is incorrect. Expected and Actual are: %d and %d", len(keyValues), len(scanResults))
err = errors.New("Len of scanResults is incorrect.")
}
FailTestIfError(err, "Len of scanResults is incorrect", t)
}
func SkipTestPerfRangeWithConcurrentKVMuts(t *testing.T) {
log.Printf("In TestPerfRangeWithConcurrentKVMuts()")
var wg sync.WaitGroup
prodfile = "../../../../../prataprc/monster/prods/test.prod"
bagdir = "../../../../../prataprc/monster/bags/"
e := secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
FailTestIfError(e, "Error in DropAllSecondaryIndexes", t)
log.Printf("Generating JSON docs")
kvdocs = GenerateJsons(1000, seed, prodfile, bagdir)
seed++
log.Printf("Setting initial JSON docs in KV")
kv.SetKeyValues(kvdocs, "default", "", clusterconfig.KVAddress)
var indexName = "index_company"
var bucketName = "default"
log.Printf("Creating a 2i")
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"company"}, false, nil, true, 1500, nil)
FailTestIfError(err, "Error in creating the index", t)
wg.Add(2)
go CreateDeleteDocsForDuration(&wg, 60)
go RangeScanForDuration_ltr("Range Thread: ", &wg, 60, t, indexName, bucketName, indexScanAddress)
wg.Wait()
}
func TestMixedDatatypesRange_Float(t *testing.T) {
log.Printf("In TestMixedDatatypesRange_Float()")
field := "mixed_field"
indexName := "index_mixeddt"
bucketName := "default"
e := secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
FailTestIfError(e, "Error in DropAllSecondaryIndexes", t)
docsToCreate := generateJSONSMixedDatatype(1000, field)
seed++
log.Printf("Setting mixed datatypes JSON docs in KV")
kvutility.SetKeyValues(docsToCreate, "default", "", clusterconfig.KVAddress)
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{field}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanResponse_float64(docs, field, 100, 1000, 3)
scanResults, err := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{100}, []interface{}{1000}, 3, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
log.Printf("Lengths of expected and actual scan results are: %d and %d", len(docScanResults), len(scanResults))
docScanResults = datautility.ExpectedScanResponse_float64(docs, field, 1, 100, 2)
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{1}, []interface{}{100}, 2, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
log.Printf("Lengths of expected and actual scan results are: %d and %d", len(docScanResults), len(scanResults))
log.Printf("Length of kv docs is %d", len(docs))
}
func TestMixedDatatypesScanAll(t *testing.T) {
log.Printf("In TestMixedDatatypesScanAll()")
log.Printf("Before test begin: Length of kv docs is %d", len(docs))
field := "md_street"
indexName := "index_mixeddt"
bucketName := "default"
e := secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
FailTestIfError(e, "Error in DropAllSecondaryIndexes", t)
docsToCreate := generateJSONSMixedDatatype(1000, "md_street")
log.Printf("After generate docs: Length of kv docs is %d", len(docs))
seed++
log.Printf("Setting mixed datatypes JSON docs in KV")
kvutility.SetKeyValues(docsToCreate, "default", "", clusterconfig.KVAddress)
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{field}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanAllResponse(docs, field)
scanResults, err := secondaryindex.ScanAll(indexName, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
log.Printf("Lengths of expected and actual scan results are: %d and %d", len(docScanResults), len(scanResults))
log.Printf("End: Length of kv docs is %d", len(docs))
}
func TestUpdateMutations_AddField(t *testing.T) {
log.Printf("In TestUpdateMutations_AddField()")
var bucketName = "default"
var indexName = "index_newField"
var field = "newField"
docsToCreate := generateDocs(1000, "users.prod")
UpdateKVDocs(docsToCreate, docs)
seed++
log.Printf("Setting JSON docs in KV")
kvutility.SetKeyValues(docsToCreate, "default", "", clusterconfig.KVAddress)
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{field}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanAllResponse(docs, field)
scanResults, err := secondaryindex.ScanAll(indexName, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
log.Printf("Count of scan results before add field mutations: %d", len(scanResults))
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
// Create mutations with add fields
AddFieldMutations(300, field) // Update documents by adding the indexed field
docScanResults = datautility.ExpectedScanAllResponse(docs, field)
scanResults, err = secondaryindex.ScanAll(indexName, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
log.Printf("Count of scan results after add field mutations: %d", len(scanResults))
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
}
// Test case for testing primary key values with longest length possible
func TestLargePrimaryKeyLength(t *testing.T) {
log.Printf("In TestLargePrimaryKeyLength()")
indexName := "index_LongPrimaryField"
bucketName := "default"
e := secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
FailTestIfError(e, "Error in DropAllSecondaryIndexes", t)
largePrimaryKeyDocs := generateLargePrimaryKeyDocs(1000, "docid")
seed++
log.Printf("Setting JSON docs in KV")
kvutility.SetKeyValues(largePrimaryKeyDocs, "default", "", clusterconfig.KVAddress)
// Create a primary index
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", nil, true, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
scanResults, err := secondaryindex.ScanAll(indexName, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
if len(scanResults) != len(docs) {
log.Printf("Len of scanResults is incorrect. Expected and Actual are: %d and %d", len(docs), len(scanResults))
err = errors.New("Len of scanResults is incorrect.")
FailTestIfError(err, "Len of scanResults is incorrect", t)
}
log.Printf("Lengths of num of docs and scanResults are: %d and %d", len(docs), len(scanResults))
log.Printf("End: Length of kv docs is %d", len(docs))
}
// Test case for testing secondary key field values as very huge
func TestLargeSecondaryKeyLength(t *testing.T) {
log.Printf("In TestLargeSecondaryKeyLength()")
field := "LongSecField"
indexName := "index_LongSecField"
bucketName := "default"
e := secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
FailTestIfError(e, "Error in DropAllSecondaryIndexes", t)
largeKeyDocs := generateLargeSecondayKeyDocs(1000, field)
seed++
log.Printf("Setting JSON docs in KV")
kvutility.SetKeyValues(largeKeyDocs, "default", "", clusterconfig.KVAddress)
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{field}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanAllResponse(docs, field)
scanResults, err := secondaryindex.ScanAll(indexName, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
log.Printf("ScanAll: Lengths of expected and actual scan results are: %d and %d", len(docScanResults), len(scanResults))
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
docScanResults = datautility.ExpectedScanResponse_string(docs, field, "A", "zzzz", 3)
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"A"}, []interface{}{"zzzz"}, 3, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
log.Printf("Range: Lengths of expected and actual scan results are: %d and %d", len(docScanResults), len(scanResults))
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
log.Printf("End: Length of kv docs is %d", len(docs))
}
func TestLookupJsonObject(t *testing.T) {
log.Printf("In TestLookupJsonObject()")
var indexName = "index_streetaddress"
var bucketName = "default"
addDocIfNotPresentInKV("User3bf51f08-0bac-4c03-bcec-5c255cbdde2c")
addDocIfNotPresentInKV("Userbb48952f-f8d1-4e04-a0e1-96b9019706fb")
time.Sleep(2 * time.Second)
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"address.streetaddress"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
value := map[string]interface{}{
"doornumber": "12B",
"floor": 5.0,
"buildingname": "Sterling Heights",
"streetname": "Hill Street"}
docScanResults := datautility.ExpectedLookupResponse_json(docs, "address.streetaddress", value)
scanResults, err := secondaryindex.Lookup(indexName, bucketName, indexScanAddress, []interface{}{value}, true, defaultlimit, c.SessionConsistency, nil)
tc.PrintScanResults(docScanResults, "docScanResults")
tc.PrintScanResults(scanResults, "scanResults")
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
}
func TestLargeDocumentSize(t *testing.T) {
log.Printf("In TestLargeDocumentSize()")
u, _ := user.Current()
datapath := filepath.Join(u.HomeDir, "testdata/TwitterFeed1.txt.gz")
tc.DownloadDataFile(tc.IndexTypesTwitterFeed1JSONDataS3, datapath, true)
largeDocs := datautility.LoadJSONFromCompressedFile(datapath, "id_str")
UpdateKVDocs(largeDocs, docs)
log.Printf("Length of docs and largeDocs = %d and %d", len(docs), len(largeDocs))
bucketName := "default"
index1 := "index_userscreenname"
kvutility.SetKeyValues(largeDocs, bucketName, "", clusterconfig.KVAddress)
err := secondaryindex.CreateSecondaryIndex(index1, bucketName, indexManagementAddress, "", []string{"`user`.screen_name"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanAllResponse(docs, "user.screen_name")
scanResults, err := secondaryindex.ScanAll(index1, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan 1: ", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan 1: result validation", t)
}
func TestFieldsWithSpecialCharacters(t *testing.T) {
log.Printf("In TestFieldsWithSpecialCharacters()")
var bucketName = "default"
var indexName = "index_specialchar"
var field = "splfield"
docsToCreate := generateDocsWithSpecialCharacters(1000, "users.prod", field)
UpdateKVDocs(docsToCreate, docs)
var valueToLookup string
for _, v := range docsToCreate {
json := v.(map[string]interface{})
valueToLookup = json[field].(string)
break
}
kvutility.SetKeyValues(docsToCreate, bucketName, "", clusterconfig.KVAddress)
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{field}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
log.Printf("Looking up for value %v", valueToLookup)
docScanResults := datautility.ExpectedScanResponse_string(docs, field, valueToLookup, valueToLookup, 3)
scanResults, err := secondaryindex.Lookup(indexName, bucketName, indexScanAddress, []interface{}{valueToLookup}, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
}
func TestSameFieldNameAtDifferentLevels(t *testing.T) {
log.Printf("In TestSameFieldNameAtDifferentLevels()")
var bucketName = "default"
var indexName = "cityindex"
var field = "city"
docsToCreate := generateDocs(1000, "users.prod")
UpdateKVDocs(docsToCreate, docs)
docsToUpload := make(tc.KeyValues)
for k, v := range docsToCreate {
json := v.(map[string]interface{})
address := json["address"].(map[string]interface{})
city := address["city"].(string)
json[field] = city
address["city"] = "ThisIsNestedCity " + city
docsToUpload[k] = json
}
seed++
log.Printf("Setting JSON docs in KV")
kvutility.SetKeyValues(docsToUpload, "default", "", clusterconfig.KVAddress)
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{field}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanResponse_string(docs, field, "A", "K", 3)
scanResults, err := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"A"}, []interface{}{"K"}, 3, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
}
func TestCompositeIndex_NumAndString(t *testing.T) {
log.Printf("In TestCompositeIndex()")
var bucketName = "default"
var indexName = "index_composite1"
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"age", "company"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
scanResults, err := secondaryindex.ScanAll(indexName, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
if len(scanResults) != len(docs) {
log.Printf("ScanAll of composite index is wrong. Expected and actual num of results: %d and %d", len(docs), len(scanResults))
e := errors.New("ScanAll of composite index is wrong")
FailTestIfError(e, "Error in TestCompositeIndex", t)
}
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{25, "F"}, []interface{}{30, "M"}, 3, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
// todo: validate the results
addDocIfNotPresentInKV("User22a44f1c-3f15-4ada-9cf5-6c24a7690a37")
docScanResults := make(tc.ScanResponse)
docScanResults["User22a44f1c-3f15-4ada-9cf5-6c24a7690a37"] = []interface{}{25.0, "ZIGGLES"}
scanResults, err = secondaryindex.Lookup(indexName, bucketName, indexScanAddress, []interface{}{25, "ZIGGLES"}, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
}
func TestMutationsWithMultipleIndexBuilds(t *testing.T) {
log.Printf("In TestMutationsWithMultipleIndexBuilds()")
prodfile = filepath.Join(proddir, "test.prod")
secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
log.Printf("Generating JSON docs")
kvdocs = GenerateJsons(100000, seed, prodfile, bagdir)
seed++
log.Printf("Setting initial JSON docs in KV")
kv.SetKeyValues(kvdocs, "default", "", clusterconfig.KVAddress)
var index_p = "index_primary"
var bucketName = "default"
indexes := []string{"index_company", "index_age", "index_firstname", "index_lastname"}
fields := []string{"company", "age", "`first-name`", "`last-name`"}
// Create a primary index
err := secondaryindex.CreateSecondaryIndex(index_p, bucketName, indexManagementAddress, "", nil, true, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
log.Printf("Creating multiple indexes in deferred mode")
for i := range indexes {
e := secondaryindex.CreateSecondaryIndexAsync(indexes[i], bucketName, indexManagementAddress, "", []string{fields[i]}, false, []byte("{\"defer_build\": true}"), true, nil)
FailTestIfError(e, "Error in creating the index", t)
}
log.Printf("Build Indexes and wait for indexes to become active: %v", indexes)
err = secondaryindex.BuildIndexes(indexes, bucketName, indexManagementAddress, 2000)
FailTestIfError(err, "Error in deferred index build", t)
}
func TestRangeWithConcurrentDelMuts(t *testing.T) {
log.Printf("In TestRangeWithConcurrentDelMuts()")
var wg sync.WaitGroup
prodfile = filepath.Join(proddir, "test.prod")
// secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
log.Printf("Generating JSON docs")
kvdocs = GenerateJsons(30000, seed, prodfile, bagdir)
seed++
log.Printf("Setting initial JSON docs in KV")
kv.SetKeyValues(kvdocs, "default", "", clusterconfig.KVAddress)
var indexName = "index_company"
var bucketName = "default"
log.Printf("Creating a 2i")
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"company"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
wg.Add(2)
go DeleteDocsForDuration(&wg, 120)
go RangeScanForDuration_ltr("Thread 1: ", &wg, 120, t, indexName, bucketName, indexScanAddress)
wg.Wait()
}
func TestCountLookup(t *testing.T) {
log.Printf("In TestCountLookup()")
var indexName = "index_age"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"age"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanResponse_float64(docs, "age", 25, 25, 3)
rangeCount, err := secondaryindex.CountLookup(indexName, bucketName, indexScanAddress, []interface{}{25}, c.SessionConsistency, nil)
FailTestIfError(err, "Error in CountRange: ", t)
log.Printf("Count of expected and actual Range are: %d and %d", len(docScanResults), rangeCount)
if int64(len(docScanResults)) != rangeCount {
e := errors.New(fmt.Sprintf("Expected Range count %d does not match actual Range count %d: ", len(docScanResults), rangeCount))
FailTestIfError(e, "Error in CountRange: ", t)
}
docScanResults = datautility.ExpectedScanResponse_float64(docs, "age", 75, 75, 3)
rangeCount, err = secondaryindex.CountLookup(indexName, bucketName, indexScanAddress, []interface{}{75}, c.SessionConsistency, nil)
FailTestIfError(err, "Error in CountRange: ", t)
log.Printf("Count of expected and actual Range are: %d and %d", len(docScanResults), rangeCount)
if int64(len(docScanResults)) != rangeCount {
e := errors.New(fmt.Sprintf("Expected Range count %d does not match actual Range count %d: ", len(docScanResults), rangeCount))
FailTestIfError(e, "Error in CountRange: ", t)
}
}
func TestScanLimitParameter(t *testing.T) {
log.Printf("In TestScanLimitParameter()")
var indexName = "index_age"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"age"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
limit := 500
scanResults, err := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{35}, []interface{}{40}, 1, true, int64(limit), c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
if len(scanResults) != limit {
e := errors.New(fmt.Sprintf("Expected %d number of results but got %d results", limit, len(scanResults)))
FailTestIfError(e, "Error in scan limit: ", t)
}
limit = 1000
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{35}, []interface{}{40}, 1, true, int64(limit), c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
if len(scanResults) != limit {
e := errors.New(fmt.Sprintf("Expected %d number of results but got %d results", limit, len(scanResults)))
FailTestIfError(e, "Error in scan limit: ", t)
}
// Todo: Verify the results in scanresults
}
func TestBasicArrayDataType_Lookup(t *testing.T) {
log.Printf("In TestBasicArrayDataType_Lookup()")
var indexName = "index_tags"
var bucketName = "default"
addDocIfNotPresentInKV("Usere46cea01-38f6-4e7b-92e5-69d64668ae75")
time.Sleep(2 * time.Second)
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"tags"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
// Document has array: "reprehenderit", "tempor", "officia", "exercitation", "labore", "sunt", "tempor"
arrayValue := []string{"reprehenderit", "tempor", "officia", "exercitation", "labore", "sunt", "tempor"}
scanResults, err := secondaryindex.Lookup(indexName, bucketName, indexScanAddress, []interface{}{arrayValue}, true, defaultlimit, c.SessionConsistency, nil)
tc.PrintScanResults(scanResults, "scanResults")
FailTestIfError(err, "Error in scan", t)
if len(scanResults) != 1 {
e := errors.New("Lookup should return exactly one result")
FailTestIfError(e, "Error in array Lookup: ", t)
}
for k := range scanResults {
if k != "Usere46cea01-38f6-4e7b-92e5-69d64668ae75" {
e := errors.New("Lookup returned a wrong key")
FailTestIfError(e, "Error in array Lookup: ", t)
}
}
}
func TestThreeIndexCreates(t *testing.T) {
log.Printf("In TestThreeIndexCreates()")
var i1 = "index_balance"
var i2 = "index_email"
var i3 = "index_pin"
var bucketName = "default"
e := secondaryindex.CreateSecondaryIndex(i1, bucketName, indexManagementAddress, "", []string{"balance"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(e, "Error in creating the index", t)
//Create docs mutations: Add new docs to KV
log.Printf("Create docs mutations")
CreateDocs(100)
docScanResults := datautility.ExpectedScanResponse_string(docs, "balance", "$1", "$2", 2)
scanResults, err := secondaryindex.Range(i1, bucketName, indexScanAddress, []interface{}{"$1"}, []interface{}{"$2"}, 2, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
err = secondaryindex.CreateSecondaryIndex(i2, bucketName, indexManagementAddress, "", []string{"email"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
//Create docs mutations: Add new docs to KV
log.Printf("Create docs mutations")
CreateDocs(100)
docScanResults = datautility.ExpectedScanResponse_string(docs, "email", "p", "w", 1)
scanResults, err = secondaryindex.Range(i2, bucketName, indexScanAddress, []interface{}{"p"}, []interface{}{"w"}, 1, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
err = secondaryindex.CreateSecondaryIndex(i3, bucketName, indexManagementAddress, "", []string{"address.pin"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
//Delete docs mutations: Delete docs from KV
log.Printf("Delete docs mutations")
DeleteDocs(150)
docScanResults = datautility.ExpectedScanResponse_float64(docs, "address.pin", 2222, 5555, 3)
scanResults, err = secondaryindex.Range(i3, bucketName, indexScanAddress, []interface{}{2222}, []interface{}{5555}, 3, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
}
func TestRangeStatistics(t *testing.T) {
log.Printf("In TestRangeCount()")
var indexName = "index_age"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"age"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
}
func TestSameIndexNameInTwoBuckets(t *testing.T) {
log.Printf("In TestSameIndexNameInTwoBuckets()")
e := secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
FailTestIfError(e, "Error in DropAllSecondaryIndexes", t)
numOfBuckets := 2
indexName := "b_idx"
indexFields := [...]string{"age", "address.city"}
bucketNames := [...]string{"default", "buck2"}
proxyPorts := [...]string{"11212", "11213"}
var bucketDocs [2]tc.KeyValues
// Update default bucket ram to 256
// Create two more buckets with ram 256 each
// Add different docs to all 3 buckets
// Create index on each of them
// Query the indexes
kvutility.FlushBucket(bucketNames[0], "", clusterconfig.Username, clusterconfig.Password, kvaddress)
kvutility.EditBucket(bucketNames[0], "", clusterconfig.Username, clusterconfig.Password, kvaddress, "256")
for i := 1; i < numOfBuckets; i++ {
kvutility.CreateBucket(bucketNames[i], "sasl", "", clusterconfig.Username, clusterconfig.Password, kvaddress, "256", proxyPorts[i])
}
time.Sleep(30 * time.Second)
log.Printf("Generating docs and Populating all the buckets")
for i := 0; i < numOfBuckets; i++ {
bucketDocs[i] = generateDocs(1000, "users.prod")
kvutility.SetKeyValues(bucketDocs[i], bucketNames[i], "", clusterconfig.KVAddress)
err := secondaryindex.CreateSecondaryIndex(indexName, bucketNames[i], indexManagementAddress, "", []string{indexFields[i]}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
}
time.Sleep(3 * time.Second)
// Scan index of first bucket
docScanResults := datautility.ExpectedScanResponse_float64(bucketDocs[0], indexFields[0], 30, 50, 1)
scanResults, err := secondaryindex.Range(indexName, bucketNames[0], indexScanAddress, []interface{}{30}, []interface{}{50}, 1, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan 1", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
// Scan index of second bucket
docScanResults = datautility.ExpectedScanResponse_string(bucketDocs[1], indexFields[1], "F", "Q", 2)
scanResults, err = secondaryindex.Range(indexName, bucketNames[1], indexScanAddress, []interface{}{"F"}, []interface{}{"Q"}, 2, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan 2", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
kvutility.EditBucket(bucketNames[0], "", clusterconfig.Username, clusterconfig.Password, kvaddress, "512")
kvutility.DeleteBucket(bucketNames[1], "", clusterconfig.Username, clusterconfig.Password, kvaddress)
time.Sleep(30 * time.Second) // Sleep after bucket create or delete
tc.ClearMap(docs)
UpdateKVDocs(bucketDocs[0], docs)
}
func SkipTestCompactionDiskMinSize(t *testing.T) {
log.Printf("In TestCompactionDiskMinSize()")
secondaryindex.DropAllSecondaryIndexes(indexManagementAddress)
log.Printf("Emptying the default bucket")
kv.EnableBucketFlush("default", "", clusterconfig.Username, clusterconfig.Password, kvaddress)
kv.FlushBucket("default", "", clusterconfig.Username, clusterconfig.Password, kvaddress)
tc.ClearMap(docs)
time.Sleep(5 * time.Second)
log.Printf("Generating JSON docs")
docs = GenerateJsons(10000, seed, filepath.Join(proddir, "test.prod"), bagdir)
seed++
log.Printf("Setting initial JSON docs in KV")
kv.SetKeyValues(docs, "default", "", clusterconfig.KVAddress)
indexName := "index_compactiontest1"
bucketName := "default"
indexField := "company"
min_sizeValue := float64(320000000)
err := secondaryindex.ChangeIndexerSettings("indexer.settings.compaction.min_size", min_sizeValue, clusterconfig.Username, clusterconfig.Password, kvaddress)
FailTestIfError(err, "Error in ChangeIndexerSettings", t)
log.Printf("Creating a 2i")
err = secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{indexField}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
stats1 := getCompactionStats(indexName, bucketName)
log.Printf("Current Compaction Stats: Fragmentation=%v, Num_Compactions=%v, Disk_Size=%v\n", stats1.frag_percent, stats1.num_compactions, stats1.disk_size)
prev_compactionnumber := stats1.num_compactions
for i := 0; i < 100; i++ {
log.Printf("ITERATION %v", i)
updateDocsFieldForFragmentation(indexField)
kv.SetKeyValues(docs, "default", "", clusterconfig.KVAddress)
stats2 := getCompactionStats(indexName, bucketName)
log.Printf("Current Compaction Stats: Fragmentation=%v, Num_Compactions=%v, Disk_Size=%0.0f\n", stats2.frag_percent, stats2.num_compactions, stats2.disk_size)
if stats2.num_compactions > prev_compactionnumber {
time.Sleep(10 * time.Second)
stats3 := getCompactionStats(indexName, bucketName)
if stats3.disk_size < min_sizeValue {
errstr := fmt.Sprintf("Index compaction occurred before disk size %0.0f reached the set min_size %0.0f", stats3.disk_size, min_sizeValue)
log.Printf(errstr)
err := errors.New(errstr)
FailTestIfError(err, "Error in TestCompactionDiskMinSize", t)
}
}
prev_compactionnumber = stats2.num_compactions
}
err = secondaryindex.ChangeIndexerSettings("indexer.settings.compaction.min_size", float64(1048576), clusterconfig.Username, clusterconfig.Password, kvaddress)
FailTestIfError(err, "Error in ChangeIndexerSettings", t)
}
func TestRangeFloatInclVariations(t *testing.T) {
log.Printf("In TestRangeFloatInclVariations()")
var indexName = "index_latitude"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"latitude"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
// Scan 1. Value close to -67.373265, Inclusion 0
log.Printf("Scan 1")
docScanResults := datautility.ExpectedScanResponse_float64(docs, "latitude", -67.373365, -67.373165, 0)
scanResults, err := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{-67.373365}, []interface{}{-67.373165}, 0, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
// Scan 2. Value close to -67.373265, Inclusion 1 ( >= low && < high) (val < low && val < high : Expected 0 result)
log.Printf("Scan 2")
docScanResults = datautility.ExpectedScanResponse_float64(docs, "latitude", -67.3732649999, -67.373264, 1)
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{-67.3732649999}, []interface{}{-67.373264}, 1, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
// Scan 3. Value close to -67.373265, Inclusion 2 ( > low && <= high) (val > low && val > high: Expect 0 result)
log.Printf("Scan 3")
docScanResults = datautility.ExpectedScanResponse_float64(docs, "latitude", -67.373265999, -67.37326500001, 2)
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{-67.373265999}, []interface{}{-67.37326500001}, 2, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
// Scan 4. Value close to -67.373265, Inclusion 2 ( > low && <= high) ( val > low && val < high: Expect 1 result)
log.Printf("Scan 4")
docScanResults = datautility.ExpectedScanResponse_float64(docs, "latitude", -67.37326500001, -67.3732649999, 2)
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{-67.37326500001}, []interface{}{-67.3732649999}, 2, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
// Scan 5. Value close to -67.373265, Inclusion 3 ( val == low && val < high : Expect 1 result)
log.Printf("Scan 5")
docScanResults = datautility.ExpectedScanResponse_float64(docs, "latitude", -67.373265, -67.3732649999, 3)
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{-67.373265}, []interface{}{-67.3732649999}, 3, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
// Scan 6. Value close to -67.373265, Inclusion 3 ( val == low && val > high : Expect 0 results)
log.Printf("Scan 6")
docScanResults = datautility.ExpectedScanResponse_float64(docs, "latitude", -67.373265, -67.37326500001, 3)
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{-67.373265}, []interface{}{-67.37326500001}, 3, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
}