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 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 TestMixedDatatypesRange_String(t *testing.T) {
log.Printf("In TestMixedDatatypesRange_String()")
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_string(docs, field, "A", "Z", 3)
scanResults, err := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"A"}, []interface{}{"Z"}, 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))
log.Printf("Length of kv docs is %d", len(docs))
}
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 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 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 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)
}
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 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 TestUpdateMutations_DataTypeChange(t *testing.T) {
log.Printf("In TestUpdateMutations_DataTypeChange()")
var bucketName = "default"
var indexName = "index_isUserActive"
var field = "isActive"
docsToCreate := generateDocs(1000, "users.prod")
UpdateKVDocs(docsToCreate, docs)
seed++
log.Printf("Setting JSON docs in KV")
kvutility.SetKeyValues(docsToCreate, "default", "", clusterconfig.KVAddress)
time.Sleep(2 * time.Second)
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)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
// Create mutations with delete fields
DataTypeChangeMutations_BoolToString(200, field) // Update documents by changing datatype of the indexed field
docScanResults = datautility.ExpectedScanAllResponse(docs, field)
scanResults, err = secondaryindex.ScanAll(indexName, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
docScanResults = datautility.ExpectedScanResponse_string(docs, field, "true", "true", 3)
scanResults, err = secondaryindex.Lookup(indexName, bucketName, indexScanAddress, []interface{}{"true"}, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
docScanResults = datautility.ExpectedScanResponse_string(docs, field, "false", "false", 3)
scanResults, err = secondaryindex.Lookup(indexName, bucketName, indexScanAddress, []interface{}{"false"}, 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 for case sensitivity of index field values
func TestSimpleIndex_FieldValueCaseSensitivity(t *testing.T) {
log.Printf("In TestSimpleIndex_StringCaseSensitivity()")
var indexName = "index_company"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"company"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanResponse_string(docs, "company", "B", "C", 1)
scanResults, err := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"B"}, []interface{}{"C"}, 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_string(docs, "company", "B", "c", 1)
scanResults, err = secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"B"}, []interface{}{"c"}, 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 TestScanAfterBucketPopulate(t *testing.T) {
log.Printf("In TestScanAfterBucketPopulate()")
log.Printf("Create an index on empty bucket, populate the bucket and Run a scan on the index")
var indexName = "index_eyeColor"
var bucketName = "default"
docScanResults := datautility.ExpectedScanResponse_string(docs, "eyeColor", "b", "c", 3)
scanResults, err := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"b"}, []interface{}{"c"}, 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 TestBasicLookup(t *testing.T) {
log.Printf("In TestBasicLookup()")
var indexName = "index_company"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"company"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanResponse_string(docs, "company", "BIOSPAN", "BIOSPAN", 3)
scanResults, err := secondaryindex.Lookup(indexName, bucketName, indexScanAddress, []interface{}{"BIOSPAN"}, 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 TestNestedIndex_String(t *testing.T) {
log.Printf("In TestNestedIndex_String()")
var indexName = "index_streetname"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"address.streetaddress.streetname"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanResponse_string(docs, "address.streetaddress.streetname", "A", "z", 3)
scanResults, err := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"A"}, []interface{}{"z"}, 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 TestCreateDropScan(t *testing.T) {
log.Printf("In TestCreateDropScan()")
var indexName = "index_cd"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"company"}, 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(indexName, 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)
err = secondaryindex.DropSecondaryIndex(indexName, bucketName, indexManagementAddress)
docScanResults = datautility.ExpectedScanResponse_string(docs, "company", "BIOSPAN", "ZILLANET", 1)
scanResults, e := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"BIOSPAN"}, []interface{}{"ZILLANET"}, 1, true, defaultlimit, c.SessionConsistency, nil)
if e == nil {
t.Fatal("Error excpected when scanning for dropped index but scan didnt fail \n")
} else {
log.Printf("Scan failed as expected with error: %v\n", e)
}
}
func TestScanAllNestedField(t *testing.T) {
log.Printf("In TestScanAllNestedField()")
var index1 = "index_streetname"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndex(index1, bucketName, indexManagementAddress, "", []string{"address.streetaddress.streetname"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanResponse_string(docs, "address.streetaddress.streetname", "A", "z", 3)
log.Printf("Length of docScanResults = %d", len(docScanResults))
scanResults, err := secondaryindex.ScanAll(index1, bucketName, indexScanAddress, defaultlimit, c.SessionConsistency, nil)
log.Printf("Length of scanResults = %d", len(scanResults))
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
}
// After bucket delete:-
// 1) query for old index before loading bucket
// 2) query for old index after loading bucket
// 3) create new indexes and query
// 4) list indexes: should list only new indexes
func TestBucketDefaultDelete(t *testing.T) {
kvutility.DeleteBucket("default", "", clusterconfig.Username, clusterconfig.Password, kvaddress)
time.Sleep(30 * time.Second) // Sleep after bucket create or delete
kvutility.CreateBucket("default", "none", "", clusterconfig.Username, clusterconfig.Password, kvaddress, "256", "11212")
time.Sleep(30 * time.Second) // Sleep after bucket create or delete
tc.ClearMap(docs)
tc.ClearMap(mut_docs)
docs = datautility.LoadJSONFromCompressedFile(dataFilePath, "docid")
mut_docs = datautility.LoadJSONFromCompressedFile(mutationFilePath, "docid")
log.Printf("Populating the default bucket")
kvutility.SetKeyValues(docs, "default", "", clusterconfig.KVAddress)
time.Sleep(2 * time.Second)
var indexName = "index_isActive"
var bucketName = "default"
scanResults, err := secondaryindex.Lookup(indexName, bucketName, indexScanAddress, []interface{}{"BIOSPAN"}, true, defaultlimit, c.SessionConsistency, nil)
if err == nil {
log.Printf("Scan did not fail as expected. Got scanresults: %v\n", scanResults)
e := errors.New("Scan did not fail as expected after bucket delete")
FailTestIfError(e, "Error in TestBucketDefaultDelete", t)
} else {
log.Printf("Scan failed as expected with error: %v", err)
}
log.Printf("Populating the default bucket after it was deleted")
kvutility.SetKeyValues(docs, "default", "", clusterconfig.KVAddress)
err = secondaryindex.CreateSecondaryIndex(indexName, bucketName, indexManagementAddress, "", []string{"company"}, false, nil, true, defaultIndexActiveTimeout, nil)
FailTestIfError(err, "Error in creating the index", t)
docScanResults := datautility.ExpectedScanResponse_string(docs, "company", "BIOSPAN", "BIOSPAN", 3)
scanResults, err = secondaryindex.Lookup(indexName, bucketName, indexScanAddress, []interface{}{"BIOSPAN"}, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
// todo: list the index and confirm there is only index created
}
func TestDeferredIndexCreate(t *testing.T) {
log.Printf("In TestDeferredIndexCreate()")
var indexName = "index_deferred"
var bucketName = "default"
err := secondaryindex.CreateSecondaryIndexAsync(indexName, bucketName, indexManagementAddress, "", []string{"company"}, false, []byte("{\"defer_build\": true}"), true, nil)
FailTestIfError(err, "Error in creating the index", t)
state, err := secondaryindex.IndexState(indexName, bucketName, indexManagementAddress)
FailTestIfError(err, "Error in getting index state for index", t)
log.Printf("Created the index %v in deferred mode. Index state is %v", indexName, state)
err = secondaryindex.BuildIndex(indexName, bucketName, indexManagementAddress, defaultIndexActiveTimeout)
FailTestIfError(err, "Error in deferred index build", t)
docScanResults := datautility.ExpectedScanResponse_string(docs, "company", "G", "M", 1)
scanResults, err := secondaryindex.Range(indexName, bucketName, indexScanAddress, []interface{}{"G"}, []interface{}{"M"}, 1, true, defaultlimit, c.SessionConsistency, nil)
FailTestIfError(err, "Error in scan of deferred index", t)
err = tv.Validate(docScanResults, scanResults)
FailTestIfError(err, "Error in scan result validation", t)
}
func TestMultipleIndexCreatesDropsWithMutations(t *testing.T) {
log.Printf("In TestThreeIndexCreates()")
var i1 = "index_state"
var i2 = "index_registered"
var i3 = "index_gender"
var i4 = "index_longitude"
var bucketName = "default"
//Testcase Flow
// Create i1, create mutations, scan i1
// Create i2, create mutations, scan i2
// Create i3, create mutations, scan i3
// Drop i2, create/delete mutations, scan i1
// Create i4, create mutations, scan i4
e := secondaryindex.CreateSecondaryIndex(i1, bucketName, indexManagementAddress, "", []string{"address.street"}, 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, "address.street", "F", "X", 2)
scanResults, err := secondaryindex.Range(i1, bucketName, indexScanAddress, []interface{}{"F"}, []interface{}{"X"}, 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{"registered"}, 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, "registered", "2014-01", "2014-09", 1)
scanResults, err = secondaryindex.Range(i2, bucketName, indexScanAddress, []interface{}{"2014-01"}, []interface{}{"2014-09"}, 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{"gender"}, 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, "gender", "male", "male", 3)
scanResults, err = secondaryindex.Lookup(i3, bucketName, indexScanAddress, []interface{}{"male"}, 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.DropSecondaryIndex(i2, bucketName, indexManagementAddress)
FailTestIfError(err, "Error dropping index", t)
//Create docs mutations: Add new docs to KV
log.Printf("Create docs mutations")
CreateDocs(100)
//Delete docs mutations: Delete docs from KV
log.Printf("Delete docs mutations")
DeleteDocs(150)
docScanResults = datautility.ExpectedScanResponse_string(docs, "address.street", "F", "X", 2)
scanResults, err = secondaryindex.Range(i1, bucketName, indexScanAddress, []interface{}{"F"}, []interface{}{"X"}, 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(i4, bucketName, indexManagementAddress, "", []string{"longitude"}, 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_float64(docs, "longitude", -50, 200, 3)
scanResults, err = secondaryindex.Range(i4, bucketName, indexScanAddress, []interface{}{-50}, []interface{}{200}, 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)
}
