summaryrefslogtreecommitdiff
path: root/jstests/tool/dumprestoreWithNoOptions.js
blob: 1062abd1e945155b59c2903bf8755f230d3e0996 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
// SERVER-6366
// relates to SERVER-808
//
// This file tests that options are not restored upon
// mongorestore with --noOptionsRestore
//
// It checks that this works both when doing a full
// database dump/restore and when doing it just for a
// single db or collection.

t = new ToolTest("dumprestoreWithNoOptions");

t.startDB("foo");
db = t.db;

// We turn this off to prevent the server from touching the 'options' field in system.namespaces.
// This is important because we check exact values of the 'options' field in this test.
db.adminCommand({setParameter: 1, newCollectionsUsePowerOf2Sizes: false});

dbname = db.getName();
dbname2 = "NOT_" + dbname;

db.dropDatabase();

var defaultFlags = {};

var options = {
    capped: true,
    size: 4096,
    autoIndexId: true
};
db.createCollection('capped', options);
assert.eq(1, db.capped.getIndexes().length, "auto index not created");
var cappedOptions = db.capped.exists().options;
for (var opt in options) {
    assert.eq(options[opt],
              cappedOptions[opt],
              'invalid option:' + tojson(options) + " " + tojson(cappedOptions));
}
assert.writeOK(db.capped.insert({x: 1}));

// Full dump/restore

t.runTool("dump", "--out", t.ext);

db.dropDatabase();
assert.eq(0, db.capped.count(), "capped not dropped");
assert.eq(0, db.capped.getIndexes().length, "indexes not dropped");

t.runTool("restore", "--dir", t.ext, "--noOptionsRestore");

assert.eq(1, db.capped.count(), "wrong number of docs restored to capped");
assert(true !== db.capped.stats().capped, "restore options were not ignored");
assert.eq(defaultFlags,
          db.capped.exists().options,
          "restore options not ignored: " + tojson(db.capped.exists()));

// Dump/restore single DB

db.dropDatabase();
var options = {
    capped: true,
    size: 4096,
    autoIndexId: true
};
db.createCollection('capped', options);
assert.eq(1, db.capped.getIndexes().length, "auto index not created");
var cappedOptions = db.capped.exists().options;
for (var opt in options) {
    assert.eq(options[opt], cappedOptions[opt], 'invalid option');
}
assert.writeOK(db.capped.insert({x: 1}));

dumppath = t.ext + "noOptionsSingleDump/";
mkdir(dumppath);
t.runTool("dump", "-d", dbname, "--out", dumppath);

db.dropDatabase();
assert.eq(0, db.capped.count(), "capped not dropped");
assert.eq(0, db.capped.getIndexes().length, "indexes not dropped");

t.runTool("restore", "-d", dbname2, "--dir", dumppath + dbname, "--noOptionsRestore");

db = db.getSiblingDB(dbname2);

assert.eq(1, db.capped.count(), "wrong number of docs restored to capped");
assert(true !== db.capped.stats().capped, "restore options were not ignored");
assert.eq(defaultFlags,
          db.capped.exists().options,
          "restore options not ignored: " + tojson(db.capped.exists()));

// Dump/restore single collection

db.dropDatabase();
var options = {
    capped: true,
    size: 4096,
    autoIndexId: true
};
db.createCollection('capped', options);
assert.eq(1, db.capped.getIndexes().length, "auto index not created");
var cappedOptions = db.capped.exists().options;
for (var opt in options) {
    assert.eq(options[opt], cappedOptions[opt], 'invalid option');
}

assert.writeOK(db.capped.insert({x: 1}));

dumppath = t.ext + "noOptionsSingleColDump/";
mkdir(dumppath);
dbname = db.getName();
t.runTool("dump", "-d", dbname, "-c", "capped", "--out", dumppath);

db.dropDatabase();

assert.eq(0, db.capped.count(), "capped not dropped");
assert.eq(0, db.capped.getIndexes().length, "indexes not dropped");

t.runTool("restore", "-d", dbname, "--drop", "--noOptionsRestore", dumppath + dbname);

db = db.getSiblingDB(dbname);

assert.eq(1, db.capped.count(), "wrong number of docs restored to capped");
assert(true !== db.capped.stats().capped, "restore options were not ignored");
assert.eq(defaultFlags,
          db.capped.exists().options,
          "restore options not ignored: " + tojson(db.capped.exists()));

t.stop();