Skip to content

Commit 2e666db

Browse files
FGasperFGasper
committed
update tests
1 parent a48050a commit 2e666db

File tree

2 files changed

+76
-170
lines changed

2 files changed

+76
-170
lines changed

‎internal/verifier/migration_verifier.go‎

Lines changed: 11 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -887,33 +887,22 @@ func (verifier *Verifier) doIndexSpecsMatch(ctx context.Context, srcSpec bson.Ra
887887
coll.DeleteOne(ctx, bson.M{"_id": insert.InsertedID})
888888
}()
889889

890-
cursor, err := coll.Aggregate(
890+
count, err := coll.CountDocuments(
891891
ctx,
892-
mongo.Pipeline{
893-
{
894-
{"$match", bson.D{{"_id", insert.InsertedID}}},
895-
{"$match", bson.D{
896-
{"$expr", bson.D{
897-
{"$eq", bson.A{
898-
"$spec",
899-
dstSpec,
900-
}},
901-
}},
902-
}},
903-
{"$project", bson.D{{"_id", 1}}},
904-
},
892+
bson.D{
893+
{"_id", insert.InsertedID},
894+
{"spec", dstSpec},
905895
},
906896
)
907-
if err != nil {
908-
return false, errors.Wrap(err, "failed to check index specification match in metadata")
909-
}
910-
var docs []bson.Raw
911-
err = cursor.All(ctx, &docs)
912-
if err != nil {
913-
return false, errors.Wrap(err, "failed to parse index specification match’s result")
897+
898+
switch count {
899+
case 0:
900+
return false, nil
901+
case 1:
902+
return true, nil
914903
}
915904

916-
return len(docs) == 1, nil
905+
return false, errors.Errorf("weirdly received %d matching index docs (should be 0 or 1)", count)
917906
}
918907

919908
/*

‎internal/verifier/migration_verifier_test.go‎

Lines changed: 65 additions & 148 deletions
Original file line numberDiff line numberDiff line change
@@ -996,161 +996,78 @@ func (suite *IntegrationTestSuite) TestVerifierCompareIndexes() {
996996
}
997997
}
998998

999-
/*
1000-
func TestVerifierCompareIndexSpecs(t *testing.T) {
1001-
// Index specification
1002-
keysDoc1 := bson.D{{"a", 1}, {"b", -1}}
1003-
// We marshal the key document twice so they are physically separate memory.
1004-
keysRaw1, err := bson.Marshal(keysDoc1)
1005-
require.NoError(t, err)
1006-
keysRaw2, err := bson.Marshal(keysDoc1)
1007-
require.NoError(t, err)
1008-
simpleIndexSpec1 := mongo.IndexSpecification{
1009-
Name: "testIndex",
1010-
Namespace: "testDB.testIndex",
1011-
KeysDocument: keysRaw1,
1012-
Version: 1}
1013-
1014-
simpleIndexSpec2 := mongo.IndexSpecification{
1015-
Name: "testIndex",
1016-
Namespace: "testDB.testIndex",
1017-
KeysDocument: keysRaw2,
1018-
Version: 2}
1019-
1020-
results := compareIndexSpecifications(&simpleIndexSpec1, &simpleIndexSpec2)
1021-
assert.Nil(t, results)
1022-
1023-
// Changing version should not be an issue
1024-
simpleIndexSpec3 := simpleIndexSpec2
1025-
simpleIndexSpec3.Version = 4
1026-
results = compareIndexSpecifications(&simpleIndexSpec1, &simpleIndexSpec3)
1027-
assert.Nil(t, results)
1028-
1029-
// Changing the key spec order matters
1030-
keysDoc3 := bson.D{{"b", -1}, {"a", 1}}
1031-
keysRaw3, err := bson.Marshal(keysDoc3)
1032-
require.NoError(t, err)
1033-
simpleIndexSpec3 = simpleIndexSpec2
1034-
simpleIndexSpec3.KeysDocument = keysRaw3
1035-
results = compareIndexSpecifications(&simpleIndexSpec1, &simpleIndexSpec3)
1036-
if assert.Equalf(t, 1, len(results), "Actual mismatches: %+v", results) {
1037-
result := results[0]
1038-
assert.Equal(t, "testIndex", result.ID)
1039-
assert.Equal(t, "testDB.testIndex", result.NameSpace)
1040-
assert.Equal(t, "KeysDocument", result.Field)
1041-
assert.Regexp(t, regexp.MustCompile("^"+Mismatch), result.Details)
1042-
assert.NotRegexp(t, regexp.MustCompile("0x"), result.Details)
1043-
}
1044-
1045-
// Shortening the key mattes
1046-
keysDoc3 = bson.D{{"a", 1}}
1047-
keysRaw3, err = bson.Marshal(keysDoc3)
1048-
require.NoError(t, err)
1049-
simpleIndexSpec3 = simpleIndexSpec2
1050-
simpleIndexSpec3.KeysDocument = keysRaw3
1051-
results = compareIndexSpecifications(&simpleIndexSpec1, &simpleIndexSpec3)
1052-
if assert.Equalf(t, 1, len(results), "Actual mismatches: %+v", results) {
1053-
result := results[0]
1054-
assert.Equal(t, "testIndex", result.ID)
1055-
assert.Equal(t, "testDB.testIndex", result.NameSpace)
1056-
assert.Equal(t, "KeysDocument", result.Field)
1057-
assert.Regexp(t, regexp.MustCompile("^"+Mismatch), result.Details)
1058-
assert.NotRegexp(t, regexp.MustCompile("0x"), result.Details)
1059-
}
999+
func (suite *IntegrationTestSuite) TestVerifierCompareIndexSpecs() {
1000+
ctx := suite.Context()
1001+
verifier := suite.BuildVerifier()
10601002

1061-
var expireAfterSeconds30, expireAfterSeconds0_1, expireAfterSeconds0_2 int32
1062-
expireAfterSeconds30 = 30
1063-
expireAfterSeconds0_1, expireAfterSeconds0_2 = 0, 0
1064-
sparseTrue := true
1065-
sparseFalse_1, sparseFalse_2 := false, false
1066-
uniqueTrue := true
1067-
uniqueFalse_1, uniqueFalse_2 := false, false
1068-
clusteredTrue := true
1069-
clusteredFalse_1, clusteredFalse_2 := false, false
1070-
fullIndexSpec1 := mongo.IndexSpecification{
1071-
Name: "testIndex",
1072-
Namespace: "testDB.testIndex",
1073-
KeysDocument: keysRaw1,
1074-
Version: 1,
1075-
ExpireAfterSeconds: &expireAfterSeconds0_1,
1076-
Sparse: &sparseFalse_1,
1077-
Unique: &uniqueFalse_1,
1078-
Clustered: &clusteredFalse_1}
1079-
1080-
fullIndexSpec2 := mongo.IndexSpecification{
1081-
Name: "testIndex",
1082-
Namespace: "testDB.testIndex",
1083-
KeysDocument: keysRaw2,
1084-
Version: 2,
1085-
ExpireAfterSeconds: &expireAfterSeconds0_2,
1086-
Sparse: &sparseFalse_2,
1087-
Unique: &uniqueFalse_2,
1088-
Clustered: &clusteredFalse_2}
1089-
1090-
results = compareIndexSpecifications(&fullIndexSpec1, &fullIndexSpec2)
1091-
assert.Nil(t, results)
1092-
1093-
// The full index spec should not equal the equivalent simple index spec.
1094-
results = compareIndexSpecifications(&fullIndexSpec1, &simpleIndexSpec2)
1095-
var diffFields []interface{}
1096-
for _, result := range results {
1097-
assert.Equal(t, "testIndex", result.ID)
1098-
assert.Equal(t, "testDB.testIndex", result.NameSpace)
1099-
assert.Regexp(t, regexp.MustCompile("^"+Mismatch), result.Details)
1100-
assert.NotRegexp(t, regexp.MustCompile("0x"), result.Details)
1101-
diffFields = append(diffFields, result.Field)
1102-
}
1103-
assert.ElementsMatch(t, []string{"Sparse", "Unique", "ExpireAfterSeconds", "Clustered"}, diffFields)
1104-
1105-
fullIndexSpec3 := fullIndexSpec2
1106-
fullIndexSpec3.ExpireAfterSeconds = &expireAfterSeconds30
1107-
results = compareIndexSpecifications(&fullIndexSpec1, &fullIndexSpec3)
1108-
if assert.Equalf(t, 1, len(results), "Actual mismatches: %+v", results) {
1109-
result := results[0]
1110-
assert.Equal(t, "testIndex", result.ID)
1111-
assert.Equal(t, "testDB.testIndex", result.NameSpace)
1112-
assert.Equal(t, "ExpireAfterSeconds", result.Field)
1113-
assert.Regexp(t, regexp.MustCompile("^"+Mismatch), result.Details)
1114-
assert.NotRegexp(t, regexp.MustCompile("0x"), result.Details)
1115-
}
1003+
cases := []struct {
1004+
label string
1005+
src bson.D
1006+
dst bson.D
1007+
shouldMatch bool
1008+
}{
1009+
{
1010+
label: "simple",
1011+
src: bson.D{
1012+
{"name", "testIndex"},
1013+
{"key", bson.M{"foo": 123}},
1014+
},
1015+
dst: bson.D{
1016+
{"name", "testIndex"},
1017+
{"key", bson.M{"foo": 123}},
1018+
},
1019+
shouldMatch: true,
1020+
},
1021+
{
1022+
label: "ignore number types",
1023+
src: bson.D{
1024+
{"name", "testIndex"},
1025+
{"key", bson.M{"foo": 123}},
1026+
},
1027+
dst: bson.D{
1028+
{"name", "testIndex"},
1029+
{"key", bson.M{"foo": float64(123)}},
1030+
},
1031+
shouldMatch: true,
1032+
},
11161033

1117-
fullIndexSpec3 = fullIndexSpec2
1118-
fullIndexSpec3.Sparse = &sparseTrue
1119-
results = compareIndexSpecifications(&fullIndexSpec1, &fullIndexSpec3)
1120-
if assert.Equalf(t, 1, len(results), "Actual mismatches: %+v", results) {
1121-
result := results[0]
1122-
assert.Equal(t, "testIndex", result.ID)
1123-
assert.Equal(t, "testDB.testIndex", result.NameSpace)
1124-
assert.Equal(t, "Sparse", result.Field)
1125-
assert.Regexp(t, regexp.MustCompile("^"+Mismatch), result.Details)
1126-
assert.NotRegexp(t, regexp.MustCompile("0x"), result.Details)
1127-
}
1034+
{
1035+
label: "find number differences",
1036+
src: bson.D{
1037+
{"name", "testIndex"},
1038+
{"key", bson.M{"foo": 1}},
1039+
},
1040+
dst: bson.D{
1041+
{"name", "testIndex"},
1042+
{"key", bson.M{"foo": -1}},
1043+
},
1044+
shouldMatch: false,
1045+
},
11281046

1129-
fullIndexSpec3 = fullIndexSpec2
1130-
fullIndexSpec3.Unique = &uniqueTrue
1131-
results = compareIndexSpecifications(&fullIndexSpec1, &fullIndexSpec3)
1132-
if assert.Equalf(t, 1, len(results), "Actual mismatches: %+v", results) {
1133-
result := results[0]
1134-
assert.Equal(t, "testIndex", result.ID)
1135-
assert.Equal(t, "testDB.testIndex", result.NameSpace)
1136-
assert.Equal(t, "Unique", result.Field)
1137-
assert.Regexp(t, regexp.MustCompile("^"+Mismatch), result.Details)
1138-
assert.NotRegexp(t, regexp.MustCompile("0x"), result.Details)
1047+
{
1048+
label: "key order differences",
1049+
src: bson.D{
1050+
{"name", "testIndex"},
1051+
{"key", bson.D{{"foo", 1}, {"bar", 1}}},
1052+
},
1053+
dst: bson.D{
1054+
{"name", "testIndex"},
1055+
{"key", bson.D{{"bar", 1}, {"foo", 1}}},
1056+
},
1057+
shouldMatch: false,
1058+
},
11391059
}
11401060

1141-
fullIndexSpec3 = fullIndexSpec2
1142-
fullIndexSpec3.Clustered = &clusteredTrue
1143-
results = compareIndexSpecifications(&fullIndexSpec1, &fullIndexSpec3)
1144-
if assert.Equalf(t, 1, len(results), "Actual mismatches: %+v", results) {
1145-
result := results[0]
1146-
assert.Equal(t, "testIndex", result.ID)
1147-
assert.Equal(t, "testDB.testIndex", result.NameSpace)
1148-
assert.Equal(t, "Clustered", result.Field)
1149-
assert.Regexp(t, regexp.MustCompile("^"+Mismatch), result.Details)
1150-
assert.NotRegexp(t, regexp.MustCompile("0x"), result.Details)
1061+
for _, curCase := range cases {
1062+
matchYN, err := verifier.doIndexSpecsMatch(
1063+
ctx,
1064+
testutil.MustMarshal(curCase.src),
1065+
testutil.MustMarshal(curCase.dst),
1066+
)
1067+
suite.Require().NoError(err)
1068+
suite.Assert().Equal(curCase.shouldMatch, matchYN, curCase.label)
11511069
}
11521070
}
1153-
*/
11541071

11551072
func (suite *IntegrationTestSuite) TestVerifierNamespaceList() {
11561073
verifier := suite.BuildVerifier()

0 commit comments

Comments
 (0)