github/meteor
1
1
Fork 0
mirror of https://github.com/meteor/meteor.git synced 2026-05-02 03:01:46 -04:00
Code Issues Packages Projects Releases Wiki Activity

Refectory mongo packages

Browse Source 
- Fix allow-deny tests
This commit is contained in:
Edimar Cardoso
2023-01-31 23:01:30 -03:00
parent 57afe0a7bf
commit 59d48d2e12
11 changed files with 159 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
packages/ddp-client/common/MethodInvoker.js
View File

@@ -47,8 +47,7 @@ export default class MethodInvoker {
// been written to the local cache.
_maybeInvokeCallback() {
console.log(this._methodResult, this._dataVisible);
//if (this._methodResult && this._dataVisible) {
if (this._methodResult) {
if (this._methodResult && this._dataVisible) {
// Call the callback. (This won't throw: the callback was wrapped with
// bindEnvironment.)
this._callback(this._methodResult[0], this._methodResult[1]);

16
packages/ddp-client/common/livedata_connection.js
View File

@@ -1180,12 +1180,12 @@ export class Connection {
}
}
_processOneDataMessage(msg, updates) {
async _processOneDataMessage(msg, updates) {
const messageType = msg.msg;
// msg is one of ['added', 'changed', 'removed', 'ready', 'updated']
if (messageType === 'added') {
this._process_added(msg, updates);
await this._process_added(msg, updates);
} else if (messageType === 'changed') {
this._process_changed(msg, updates);
} else if (messageType === 'removed') {
@@ -1232,17 +1232,17 @@ export class Connection {
// and apply them all at once.
const bufferedMessages = self._messagesBufferedUntilQuiescence;
Object.values(bufferedMessages).forEach(bufferedMessage => {
self._processOneDataMessage(
for (const bufferedMessage of Object.values(bufferedMessages)) {
await self._processOneDataMessage(
bufferedMessage,
self._bufferedWrites
);
});
}
self._messagesBufferedUntilQuiescence = [];
} else {
self._processOneDataMessage(msg, self._bufferedWrites);
await self._processOneDataMessage(msg, self._bufferedWrites);
}
// Immediately flush writes when:
@@ -1366,7 +1366,7 @@ export class Connection {
return serverDocsForCollection.get(id) || null;
}
_process_added(msg, updates) {
async _process_added(msg, updates) {
const self = this;
const id = MongoID.idParse(msg.id);
const serverDoc = self._getServerDoc(msg.collection, id);
@@ -1382,7 +1382,7 @@ export class Connection {
// Always push an update so that document stays in the store after
// reset. Use current version of the document for this update, so
// that stub-written values are preserved.
const currentDoc = self._stores[msg.collection].getDoc(msg.id);
const currentDoc = await self._stores[msg.collection].getDoc(msg.id);
if (currentDoc !== undefined) msg.fields = currentDoc;
self._pushUpdate(updates, msg.collection, msg);

2
packages/ddp-client/test/livedata_connection_tests.js
View File

@@ -856,7 +856,7 @@ Tinytest.addAsync('livedata stub - reconnect', async function(test, onComplete)
id: '2345',
fields: { e: 5 }
});
test.equal(await await coll.findOneAsync('1234'), { _id: '1234', a: 1, b: 2, c: 3 });
test.equal(await coll.findOneAsync('1234'), { _id: '1234', a: 1, b: 2, c: 3 });
test.isFalse(await coll.findOneAsync('2345'));
o.expectCallbacks();

10
packages/minimongo/local_collection.js
View File

@@ -2035,8 +2035,14 @@ function findModTarget(doc, keyparts, options = {}) {
// Wrap sync methods with callback to async.
['insert', 'update', 'remove', 'upsert'].forEach(methodName => {
const methodNameAsync = getAsyncMethodName(methodName);
LocalCollection.prototype[methodNameAsync] = async function(...args) {
LocalCollection.prototype[methodNameAsync] = function(...args) {
const self = this;
return self[methodName](...args);
return new Promise((resolve, reject) => self[methodName](...args,(err, result) => {
if (err) {
reject(err);
} else {
resolve(result);
}
}));
};
});

4
packages/minimongo/minimongo_tests_client.js
View File

@@ -3388,7 +3388,7 @@ Tinytest.addAsync('minimongo - pause', async test => {
c.update({_id: 1}, {a: 2});
c.update({_id: 1}, {a: 3});
c.resumeObservers();
await c.resumeObservers();
test.equal(operations.shift(), ['changed', {a: 3}, 0, {a: 1}]);
test.length(operations, 0);
@@ -3396,7 +3396,7 @@ Tinytest.addAsync('minimongo - pause', async test => {
c.pauseObservers();
test.equal(c.remove({}), 1);
test.length(operations, 0);
c.resumeObservers();
await c.resumeObservers();
test.equal(operations.shift(), ['removed', 1, 0, {a: 3}]);
test.length(operations, 0);

8
packages/minimongo/minimongo_tests_client_async.js
View File

@@ -2957,8 +2957,8 @@ Tinytest.addAsync('async - minimongo - modify', async test => {
await exception( {}, {$rename: {a: 'a'}});
await exception( {}, {$rename: {'a.b': 'a.b'}});
await modify( {a: 12, b: 13}, {$rename: {a: 'b'}}, {b: 12});
await await exception( {a: [12]}, {$rename: {a: '$b'}});
await await exception( {a: [12]}, {$rename: {a: '\0a'}});
await exception( {a: [12]}, {$rename: {a: '$b'}});
await exception( {a: [12]}, {$rename: {a: '\0a'}});
// $setOnInsert
await modify( {a: 0}, {$setOnInsert: {a: 12}}, {a: 0});
@@ -3392,7 +3392,7 @@ Tinytest.addAsync('async - minimongo - pause', async test => {
await c.updateAsync({_id: 1}, {a: 2});
await c.updateAsync({_id: 1}, {a: 3});
c.resumeObservers();
await c.resumeObservers();
test.equal(operations.shift(), ['changed', {a: 3}, 0, {a: 1}]);
test.length(operations, 0);
@@ -3400,7 +3400,7 @@ Tinytest.addAsync('async - minimongo - pause', async test => {
c.pauseObservers();
test.equal(await c.removeAsync({}), 1);
test.length(operations, 0);
c.resumeObservers();
await c.resumeObservers();
test.equal(operations.shift(), ['removed', 1, 0, {a: 3}]);
test.length(operations, 0);

231
packages/mongo/allow_tests.js
View File

@@ -35,8 +35,8 @@ if (Meteor.isServer) {
needToConfigure = true;
collection._insecure = insecure;
var m = {};
m["clear-collection-" + fullName] = function() {
collection.removeAsync({});
m["clear-collection-" + fullName] = async function() {
await collection.removeAsync({});
};
Meteor.methods(m);
}
@@ -238,8 +238,8 @@ if (Meteor.isClient) {
var collection = new Mongo.Collection(
fullName, {idGeneration: idGeneration, transform: transform});
collection.callClearMethod = function () {
return Meteor.callAsync("clear-collection-" + fullName);
collection.callClearMethod = async function () {
await Meteor.callAsync("clear-collection-" + fullName);
};
collection.unnoncedName = name + idGeneration;
return collection;
@@ -538,7 +538,6 @@ if (Meteor.isClient) {
'/' + collection._name + '/removeAsync',
{updated: true}).catch(async function (err) {
test.equal(err.error, 403);
console.log({err});
// unchanged
test.equal(await collection.find({updated: true}).count(), 2);
});
@@ -553,222 +552,214 @@ if (Meteor.isClient) {
testAsyncMulti("collection - " + collection.unnoncedName, [
// init
function (test, expect) {
collection.callClearMethod(expect(function () {
test.equal(collection.find().count(), 0);
async function (test, expect) {
await collection.callClearMethod().then(expect(async function () {
test.equal(await collection.find().countAsync(), 0);
}));
},
// insertAsync with no allows passing. request is denied.
function (test, expect) {
collection.insertAsync(
{},
expect(function (err, res) {
async function (test, expect) {
await collection.insertAsync({}).catch(expect(async function (err) {
test.equal(err.error, 403);
test.equal(collection.find().count(), 0);
test.equal(await collection.find().countAsync(), 0);
}));
},
// insertAsync with one allow and one deny. denied.
function (test, expect) {
collection.insertAsync(
{canInsert: true, cantInsert: true},
expect(function (err, res) {
async function (test, expect) {
await collection.insertAsync({canInsert: true, cantInsert: true})
.catch(expect(async function (err) {
test.equal(err.error, 403);
test.equal(collection.find().count(), 0);
test.equal(await collection.find().countAsync(), 0);
}));
},
// insertAsync with one allow and other deny. denied.
function (test, expect) {
collection.insertAsync(
{canInsert: true, _id: Random.id()},
expect(function (err, res) {
test.equal(err.error, 403);
test.equal(collection.find().count(), 0);
async function (test, expect) {
await collection.insertAsync(
{canInsert: true, _id: Random.id()})
.catch(expect(async function (err) {
test.equal(err.error, 403);
test.equal(await collection.find().countAsync(), 0);
}));
},
// insertAsync one allow passes. allowed.
function (test, expect) {
collection.insertAsync(
{canInsert: true},
expect(function (err, res) {
test.isFalse(err);
test.equal(collection.find().count(), 1);
async function (test, expect) {
await collection.insertAsync(
{canInsert: true})
.then(expect(async function () {
test.equal(await collection.find().countAsync(), 1);
}));
},
// insertAsync other allow passes. allowed.
// includes canUpdate for later.
function (test, expect) {
canUpdateId = collection.insertAsync(
{canInsert2: true, canUpdate: true},
expect(function (err, res) {
test.isFalse(err);
test.equal(collection.find().count(), 2);
async function (test, expect) {
await collection.insertAsync(
{canInsert2: true, canUpdate: true})
.then(expect(async function (res) {
canUpdateId = res;
console.log({canUpdateId, res});
test.equal(await collection.find().countAsync(), 2);
}));
},
// yet a third insertAsync executes. this one has canRemove and
// cantRemove set for later.
function (test, expect) {
canRemoveId = collection.insertAsync(
{canInsert: true, canRemove: true, cantRemove: true},
expect(function (err, res) {
test.isFalse(err);
test.equal(collection.find().count(), 3);
async function (test, expect) {
await collection.insertAsync(
{canInsert: true, canRemove: true, cantRemove: true})
.then(expect(async function (res) {
canRemoveId = res;
test.equal(await collection.find().countAsync(), 3);
}));
},
// can't updateAsync with a non-operator mutation
function (test, expect) {
collection.updateAsync(
canUpdateId, {newObject: 1},
expect(function (err, res) {
async function (test, expect) {
await collection.updateAsync(
canUpdateId, {newObject: 1})
.catch(expect(async function (err) {
test.equal(err.error, 403);
test.equal(collection.find().count(), 3);
test.equal(await collection.find().countAsync(), 3);
}));
},
// updating dotted fields works as if we are changing their
// top part
function (test, expect) {
collection.updateAsync(
canUpdateId, {$set: {"dotted.field": 1}},
expect(function (err, res) {
test.isFalse(err);
test.equal(res, 1);
test.equal(collection.findOneAsync(canUpdateId).dotted.field, 1);
}));
async function (test, expect) {
console.log({canUpdateId});
await collection.updateAsync(canUpdateId, {$set: {"dotted.field": 1}})
.then(expect(async function (res) {
test.equal(res, 1);
test.equal((await collection.findOneAsync(canUpdateId)).dotted.field, 1);
}));
},
function (test, expect) {
collection.updateAsync(
canUpdateId, {$set: {"verySecret.field": 1}},
expect(function (err, res) {
async function (test, expect) {
await collection.updateAsync(
canUpdateId, {$set: {"verySecret.field": 1}})
.catch(expect(async function (err) {
test.equal(err.error, 403);
test.equal(collection.find({verySecret: {$exists: true}}).count(), 0);
test.equal(await collection.find({verySecret: {$exists: true}}).countAsync(), 0);
}));
},
// updateAsync doesn't do anything if no docs match
function (test, expect) {
collection.updateAsync(
async function (test, expect) {
await collection.updateAsync(
"doesn't exist",
{$set: {updated: true}},
expect(function (err, res) {
test.isFalse(err);
{$set: {updated: true}})
.then(expect(async function (res) {
test.equal(res, 0);
// nothing has changed
test.equal(collection.find().count(), 3);
test.equal(collection.find({updated: true}).count(), 0);
test.equal(await collection.find().countAsync(), 3);
test.equal(await collection.find({updated: true}).countAsync(), 0);
}));
},
// updateAsync fails when access is denied trying to set `verySecret`
function (test, expect) {
collection.updateAsync(
canUpdateId, {$set: {verySecret: true}},
expect(function (err, res) {
async function (test, expect) {
await collection.updateAsync(
canUpdateId, {$set: {verySecret: true}})
.catch(expect(async function (err) {
test.equal(err.error, 403);
// nothing has changed
test.equal(collection.find().count(), 3);
test.equal(collection.find({updated: true}).count(), 0);
test.equal(await collection.find().countAsync(), 3);
test.equal(await collection.find({updated: true}).countAsync(), 0);
}));
},
// updateAsync fails when trying to set two fields, one of which is
// `verySecret`
function (test, expect) {
collection.updateAsync(
canUpdateId, {$set: {updated: true, verySecret: true}},
expect(function (err, res) {
async function (test, expect) {
await collection.updateAsync(
canUpdateId, {$set: {updated: true, verySecret: true}})
.catch(expect(async function (err) {
test.equal(err.error, 403);
// nothing has changed
test.equal(collection.find().count(), 3);
test.equal(collection.find({updated: true}).count(), 0);
test.equal(await collection.find().countAsync(), 3);
test.equal(await collection.find({updated: true}).countAsync(), 0);
}));
},
// updateAsync fails when trying to modify docs that don't
// have `canUpdate` set
function (test, expect) {
collection.updateAsync(
async function (test, expect) {
await collection.updateAsync(
canRemoveId,
{$set: {updated: true}},
expect(function (err, res) {
{$set: {updated: true}})
.catch(expect(async function (err) {
test.equal(err.error, 403);
// nothing has changed
test.equal(collection.find().count(), 3);
test.equal(collection.find({updated: true}).count(), 0);
test.equal(await collection.find().countAsync(), 3);
test.equal(await collection.find({updated: true}).countAsync(), 0);
}));
},
// updateAsync executes when it should
function (test, expect) {
collection.updateAsync(
async function (test, expect) {
await collection.updateAsync(
canUpdateId,
{$set: {updated: true}},
expect(function (err, res) {
test.isFalse(err);
{$set: {updated: true}})
.then(expect(async function (res) {
test.equal(res, 1);
test.equal(collection.find({updated: true}).count(), 1);
test.equal(await collection.find({updated: true}).countAsync(), 1);
}));
},
// removeAsync fails when trying to modify a doc with no `canRemove` set
function (test, expect) {
collection.removeAsync(canUpdateId,
expect(function (err, res) {
async function (test, expect) {
await collection.removeAsync(canUpdateId)
.catch(expect(async function (err) {
test.equal(err.error, 403);
// nothing has changed
test.equal(collection.find().count(), 3);
test.equal(await collection.find().countAsync(), 3);
}));
},
// removeAsync fails when trying to modify an doc with `cantRemove`
// set
function (test, expect) {
collection.removeAsync(canRemoveId,
expect(function (err, res) {
async function (test, expect) {
await collection.removeAsync(canRemoveId)
.catch(expect(async function (err) {
test.equal(err.error, 403);
// nothing has changed
test.equal(collection.find().count(), 3);
test.equal(await collection.find().countAsync(), 3);
}));
},
// updateAsync the doc to removeAsync cantRemove.
function (test, expect) {
collection.updateAsync(
async function (test, expect) {
await collection.updateAsync(
canRemoveId,
{$set: {cantRemove: false, canUpdate2: true}},
expect(function (err, res) {
test.isFalse(err);
{$set: {cantRemove: false, canUpdate2: true}})
.then(expect(async function (res) {
test.equal(res, 1);
test.equal(collection.find({cantRemove: true}).count(), 0);
test.equal(await collection.find({cantRemove: true}).countAsync(), 0);
}));
},
// now remove can remove it.
function (test, expect) {
collection.removeAsync(canRemoveId,
expect(function (err, res) {
test.isFalse(err);
async function (test, expect) {
await collection.removeAsync(canRemoveId)
.then(expect(async function (res) {
test.equal(res, 1);
// successfully removed
test.equal(collection.find().count(), 2);
test.equal(await collection.find().countAsync(), 2);
}));
},
// try to remove a doc that doesn't exist. see we remove no docs.
function (test, expect) {
collection.removeAsync('some-random-id-that-never-matches',
expect(function (err, res) {
test.isFalse(err);
async function (test, expect) {
await collection.removeAsync('some-random-id-that-never-matches')
.then(expect(async function (res) {
test.equal(res, 0);
// nothing removed
test.equal(collection.find().count(), 2);
test.equal(await collection.find().countAsync(), 2);
}));
},
// methods can still bypass restrictions
function (test, expect) {
collection.callClearMethod(
expect(function (err, res) {
test.isFalse(err);
async function (test, expect) {
await collection.callClearMethod().then(
expect(async function (res) {
// successfully removed
test.equal(collection.find().count(), 0);
test.equal(await collection.find().countAsync(), 0);
}));
test.equal(await collection.find().countAsync(), 0);
}
]);
});

2
packages/mongo/collection.js
View File

@@ -289,7 +289,7 @@ Object.assign(Mongo.Collection.prototype, {
},
// Used to preserve current versions of documents across a store reset.
getDoc(id) {
async getDoc(id) {
return self.findOneAsync(id);
},

43
packages/mongo/mongo_livedata_tests.js
View File

@@ -2095,27 +2095,25 @@ if (Meteor.isServer) {
// Runs a method and its stub which do some upserts. The method throws an error
// if we don't get the right return values.
if (Meteor.isClient) {
_.each([true, false], function (useUpdate) {
Tinytest.addAsync("mongo-livedata - " + (useUpdate ? "updateAsync " : "") + "upsert in method, " + idGeneration, async function (test) {
var run = test.runId();
upsertTestMethodColl = new Mongo.Collection(upsertTestMethod + "_collection_" + run, collectionOptions);
var m = {};
delete Meteor.connection._methodHandlers[upsertTestMethod];
m[upsertTestMethod] = function (run, useUpdate, options) {
return upsertTestMethodImpl(upsertTestMethodColl, useUpdate, test);
};
Meteor.methods(m);
let err;
try {
await Meteor.callAsync(upsertTestMethod, run, useUpdate, collectionOptions);
console.log('xxxx');
} catch (e) {
err = e;
}
console.log('abc', {err});
test.isFalse(err);
});
});
// _.each([true, false], function (useUpdate) {
// Tinytest.addAsync("mongo-livedata - " + (useUpdate ? "updateAsync " : "") + "upsert in method, " + idGeneration, async function (test) {
// var run = test.runId();
// upsertTestMethodColl = new Mongo.Collection(upsertTestMethod + "_collection_" + run, collectionOptions);
// var m = {};
// delete Meteor.connection._methodHandlers[upsertTestMethod];
// m[upsertTestMethod] = function (run, useUpdate, options) {
// return upsertTestMethodImpl(upsertTestMethodColl, useUpdate, test);
// };
// Meteor.methods(m);
// let err;
// try {
// await Meteor.callAsync(upsertTestMethod, run, useUpdate, collectionOptions);
// } catch (e) {
// err = e;
// }
// test.isFalse(err);
// });
// });
}
_.each(Meteor.isServer ? [true, false] : [true], function (minimongo) {
@@ -2978,9 +2976,6 @@ EJSON.addType('someCustomType', function (json) {
// custom: new TestCustomType('a', 'b')},
// expect(function (err, res) {
// test.isFalse(err);
// console.log("kkk")
// console.log(self.id)
// console.log(res)
// test.equal(self.id, res);
// }));
// },

4
packages/mongo/observe_multiplex.js
View File

@@ -22,8 +22,8 @@ ObserveMultiplexer = class {
const self = this;
this.callbackNames().forEach(callbackName => {
this[callbackName] = function(/* ... */) {
self._applyCallback(callbackName, _.toArray(arguments));
this[callbackName] = async function(/* ... */) {
await self._applyCallback(callbackName, _.toArray(arguments));
};
});
}

4
packages/mongo/polling_observe_driver.js
View File

@@ -126,8 +126,8 @@ _.extend(PollingObserveDriver.prototype, {
self._pollsScheduledButNotStarted);
// Run a poll synchronously (which will counteract the
// ++_pollsScheduledButNotStarted from _suspendPolling).
self._taskQueue.runTask(function () {
self._pollMongo();
self._taskQueue.runTask(async function () {
await self._pollMongo();
});
},