// SERVER-2326 - make sure that sharding only works with unique indices
(function() {

    var s = new ShardingTest({name: "shard_index", shards: 2, mongos: 1});

    // Regenerate fully because of SERVER-2782
    for (var i = 0; i < 22; i++) {
        var coll = s.admin._mongo.getDB("test").getCollection("foo" + i);
        coll.drop();

        var bulk = coll.initializeUnorderedBulkOp();
        for (var j = 0; j < 300; j++) {
            bulk.insert({num: j, x: 1});
        }
        assert.writeOK(bulk.execute());

        if (i == 0) {
            s.adminCommand({enablesharding: "" + coll._db});
            s.ensurePrimaryShard(coll.getDB().getName(), 'shard0001');
        }

        print("\n\n\n\n\nTest # " + i);

        if (i == 0) {
            // Unique index exists, but not the right one.
            coll.ensureIndex({num: 1}, {unique: true});
            coll.ensureIndex({x: 1});

            passed = false;
            try {
                s.adminCommand({shardcollection: "" + coll, key: {x: 1}});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(!passed, "Should not shard collection when another unique index exists!");
        }
        if (i == 1) {
            // Unique index exists as prefix, also index exists
            coll.ensureIndex({x: 1});
            coll.ensureIndex({x: 1, num: 1}, {unique: true});

            try {
                s.adminCommand({shardcollection: "" + coll, key: {x: 1}});
            } catch (e) {
                print(e);
                assert(false, "Should be able to shard non-unique index without unique option.");
            }
        }
        if (i == 2) {
            // Non-unique index exists as prefix, also index exists.  No unique index.
            coll.ensureIndex({x: 1});
            coll.ensureIndex({x: 1, num: 1});

            passed = false;
            try {
                s.adminCommand({shardcollection: "" + coll, key: {x: 1}});
                passed = true;

            } catch (e) {
                print(e);
                assert(
                    !passed,
                    "Should be able to shard collection with no unique index if unique not specified.");
            }
        }
        if (i == 3) {
            // Unique index exists as prefix, also unique index exists
            coll.ensureIndex({num: 1}, {unique: true});
            coll.ensureIndex({num: 1, x: 1}, {unique: true});

            try {
                s.adminCommand({shardcollection: "" + coll, key: {num: 1}, unique: true});
            } catch (e) {
                print(e);
                assert(false, "Should be able to shard collection with unique prefix index.");
            }
        }
        if (i == 4) {
            // Unique index exists as id, also unique prefix index exists
            coll.ensureIndex({_id: 1, num: 1}, {unique: true});

            try {
                s.adminCommand({shardcollection: "" + coll, key: {_id: 1}, unique: true});
            } catch (e) {
                print(e);
                assert(false, "Should be able to shard collection with unique id index.");
            }
        }
        if (i == 5) {
            // Unique index exists as id, also unique prefix index exists
            coll.ensureIndex({_id: 1, num: 1}, {unique: true});

            try {
                s.adminCommand({shardcollection: "" + coll, key: {_id: 1, num: 1}, unique: true});
            } catch (e) {
                print(e);
                assert(false,
                       "Should be able to shard collection with unique combination id index.");
            }
        }
        if (i == 6) {
            coll.remove({});

            // Unique index does not exist, also unique prefix index exists
            coll.ensureIndex({num: 1, _id: 1}, {unique: true});

            try {
                s.adminCommand({shardcollection: "" + coll, key: {num: 1}, unique: true});
            } catch (e) {
                print(e);
                assert(
                    false,
                    "Should be able to shard collection with no unique index but with a unique prefix index.");
            }

            printjson(coll.getIndexes());

            // Make sure the index created is unique!
            assert.eq(1,
                      coll.getIndexes().filter(function(z) {
                          return friendlyEqual(z.key, {num: 1}) && z.unique;
                      }).length);
        }
        if (i == 7) {
            coll.remove({});

            // No index exists

            try {
                assert.eq(coll.find().itcount(), 0);
                s.adminCommand({shardcollection: "" + coll, key: {num: 1}});
            } catch (e) {
                print(e);
                assert(false, "Should be able to shard collection with no index on shard key.");
            }
        }
        if (i == 8) {
            coll.remove({});

            // No index exists

            passed = false;
            try {
                assert.eq(coll.find().itcount(), 0);
                s.adminCommand({shardcollection: "" + coll, key: {num: 1}, unique: true});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(
                passed,
                "Should be able to shard collection with unique flag but with no unique index on shard key, if coll empty.");

            printjson(coll.getIndexes());

            // Make sure the index created is unique!
            assert.eq(1,
                      coll.getIndexes().filter(function(z) {
                          return friendlyEqual(z.key, {num: 1}) && z.unique;
                      }).length);
        }
        if (i == 9) {
            // Unique index exists on a different field as well
            coll.ensureIndex({num: 1}, {unique: true});
            coll.ensureIndex({x: 1});

            passed = false;
            try {
                s.adminCommand({shardcollection: "" + coll, key: {x: 1}});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(!passed, "Should not shard collection when another unique index exists!");
        }
        if (i == 10) {
            // try sharding non-empty collection without any index
            passed = false;
            try {
                s.adminCommand({shardcollection: "" + coll, key: {num: 1}});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(!passed, "Should not be able to shard without index");

            // now add containing index and try sharding by prefix
            coll.ensureIndex({num: 1, x: 1});

            try {
                s.adminCommand({shardcollection: "" + coll, key: {num: 1}});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(passed, "Should be able to shard collection with prefix of existing index");

            printjson(coll.getIndexes());

            // make sure no extra index is created
            assert.eq(2, coll.getIndexes().length);
        }
        if (i == 11) {
            coll.remove({});

            // empty collection with useful index. check new index not created
            coll.ensureIndex({num: 1, x: 1});

            try {
                s.adminCommand({shardcollection: "" + coll, key: {num: 1}});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(passed, "Should be able to shard collection with prefix of existing index");

            printjson(coll.getIndexes());

            // make sure no extra index is created
            assert.eq(2, coll.getIndexes().length);
        }
        if (i == 12) {
            // check multikey values for x make index unusable for shard key
            coll.save({num: 100, x: [2, 3]});
            coll.ensureIndex({num: 1, x: 1});

            passed = false;
            try {
                s.adminCommand({shardcollection: "" + coll, key: {num: 1}});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(!passed, "Should not be able to shard collection with mulikey index");
        }
        if (i == 13) {
            coll.save({num: [100, 200], x: 10});
            coll.ensureIndex({num: 1, x: 1});

            passed = false;
            try {
                s.adminCommand({shardcollection: "" + coll, key: {num: 1}});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(!passed, "Should not be able to shard collection with mulikey index");
        }
        if (i == 14) {
            coll.save({num: 100, x: 10, y: [1, 2]});
            coll.ensureIndex({num: 1, x: 1, y: 1});

            passed = false;
            try {
                s.adminCommand({shardcollection: "" + coll, key: {num: 1}});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(!passed, "Should not be able to shard collection with mulikey index");
        }
        if (i == 15) {
            // try sharding with a hashed index
            coll.ensureIndex({num: "hashed"});

            try {
                s.adminCommand({shardcollection: "" + coll, key: {num: "hashed"}});
            } catch (e) {
                print(e);
                assert(false, "Should be able to shard collection with hashed index.");
            }
        }
        if (i == 16) {
            // create hashed index, but try to declare it unique when sharding
            coll.ensureIndex({num: "hashed"});

            passed = false;
            try {
                s.adminCommand({shardcollection: "" + coll, key: {num: "hashed"}, unique: true});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(!passed, "Should not be able to declare hashed shard key unique.");
        }
        if (i == 17) {
            // create hashed index, but unrelated unique index present
            coll.ensureIndex({x: "hashed"});
            coll.ensureIndex({num: 1}, {unique: true});

            passed = false;
            try {
                s.adminCommand({shardcollection: "" + coll, key: {x: "hashed"}});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(!passed,
                   "Should not be able to shard on hashed index with another unique index");
        }
        if (i == 18) {
            // create hashed index, and a regular unique index exists on same field
            coll.ensureIndex({num: "hashed"});
            coll.ensureIndex({num: 1}, {unique: true});

            try {
                s.adminCommand({shardcollection: "" + coll, key: {num: "hashed"}});
            } catch (e) {
                print(e);
                assert(false, "Should be able to shard coll with hashed and regular unique index");
            }
        }
        if (i == 19) {
            // Create sparse index.
            coll.ensureIndex({x: 1}, {sparse: true});

            passed = false;
            try {
                s.adminCommand({shardcollection: "" + coll, key: {x: 1}});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(!passed, "Should not be able to shard coll with sparse index");
        }
        if (i == 20) {
            // Create partial index.
            coll.ensureIndex({x: 1}, {filter: {num: {$gt: 1}}});

            passed = false;
            try {
                s.adminCommand({shardcollection: "" + coll, key: {x: 1}});
                passed = true;
            } catch (e) {
                print(e);
            }
            assert(!passed, "Should not be able to shard coll with partial index");
        }
        if (i == 21) {
            // Ensure that a collection with a normal index and a partial index can be sharded,
            // where
            // both are prefixed by the shard key.

            coll.ensureIndex({x: 1, num: 1}, {filter: {num: {$gt: 1}}});
            coll.ensureIndex({x: 1, num: -1});

            try {
                s.adminCommand({shardcollection: "" + coll, key: {x: 1}});
            } catch (e) {
                print(e);
                assert(false, "Should be able to shard coll with regular and partial index");
            }
        }
    }

    s.stop();

})();
