.then(() => {
expect(getState().persistenceQueue.count()).to.eql(1)
stub.returns(Promise.resolve())
dispatch(createStickyAction({x: 1, y: 2, body: 'some other sticky', uuid: 'some uuid'}))
expect(getState().persistenceQueue.count()).to.eql(2)
stub.reset()
stub.returns(Promise.resolve())
})
filterByStigmas(stigma: string) {
if (stigma && stigma !== 'all') {
return Promise.resolve(this.$filter('filterWhoHasStigma')(this.data, stigma))
.then((data: Array<Object>) => {
this.data = data;
});
}
return Promise.resolve();
}
function postImportRoutine(db) {
if (db.sequelize.dialect.name === 'postgres') {
return Promise.resolve(_.toArray(db.models))
.map(model => {
return updatePostgresSequence(model, db);
});
}
return Promise.resolve(null);
}
public findBy(by: Object): Promise<Token | null> {
if ((by as any).token === "test" || (by as any).token === "testexpired") {
return Promise.resolve({
createdDate: moment(new Date()).subtract({days: 1}).toDate(),
expiredDate: moment(new Date()).add({days: 1}).toDate(),
token: "test",
user: {},
} as any);
} else {
return Promise.resolve(null);
}
}
.catch(function (error: any) {
if (error && error.error && error.name == 'indexed_db_went_bad') {
// we are in private mode...
console.log('private mode...')
inMemory = true;
_db = new PouchDB("pxt-" + pxt.storage.storageId(), { adapter: 'memory' })
return Promise.resolve(_db);
} else {
_db = temp;
return Promise.resolve(_db);
}
})
private makeCookieAuthPromise() {
if (this.authType !== 'cookie') return Bluebird.resolve();
return Bluebird.resolve().then(() => {
return this.client.post(this.compositeUri({prefix: '', uri: '/login.action'}))
.type('form')
.send({ os_username: this.username, os_password: this.password })
.then(o => o.body)
.catch(e => {
throw new Error('CookieAuth has failed');
});
});
}
/**
* Parses an OBD output into useful data for developers
* @param {String} str
* @return {Object}
*/
function parseObdString (str: string) : Promise<OBDOutput|null> {
log('parsing command string %s', str);
let bytes = getByteGroupings(str);
let ret:OBDOutput = {
ts: new Date(),
bytes: str,
value: null,
pretty: null
};
if (!isHex(str)) {
log(
'received generic (non hex) string output "%s", not parsing',
str
);
return Promise.resolve(ret);
} else if (bytes && bytes[0] === OBD_OUTPUT_MESSAGE_TYPES.MODE_01) {
log(
'received valid output "%s" of type "%s", parsing',
str,
OBD_OUTPUT_MESSAGE_TYPES.MODE_01
);
let pidCode: string = bytes[1];
let pid:PID|null = pids.getPidByPidCode(pidCode);
if (pid) {
log(`we have a matching class for code "${pidCode}"`);
// We have a class that knows how to deal with this pid output. Parse it!
ret.pretty = pid.getFormattedValueForBytes(bytes);
// pass all bytes returned and have the particular PID figure it out
ret.value = pid.getValueForBytes(bytes.slice(0));
ret.name = pid.getName();
ret.pid = pid.getPid()
return Promise.resolve(ret);
} else {
log('no match found for pid %s', pidCode);
// Emit the data, but just the raw bytes
return Promise.resolve(ret);
}
} else {
// Wasn't a recognised message type - was probably our own bytes
// since the serial module outputs those as "data" for some reason
return Promise.resolve(null);
}
}
export function getResourceBufferPromise(resource:ReadableStream|Buffer|string):Promise<Buffer> {
// might be a string
if (typeof resource === 'string') {
return Promise.resolve(new Buffer(resource));
}
// might already be a Buffer
if (resource instanceof Buffer) {
return Promise.resolve(resource);
}
// probably a stream
// TODO npe/type check
return this.streamPromise(resource);
}
exec(
visitedNamespaceTbl?: { [key: string]: Namespace },
state?: any
): Promise<Output[]> {
var doc = this.doc;
var namespace = doc.namespace;
if(state) this.state = state;
if(!visitedNamespaceTbl) visitedNamespaceTbl = {};
visitedNamespaceTbl[namespace.id] = namespace;
return(Promise.resolve(this.prepare()).then((output: Output) => Promise.map(
namespace.getUsedImportList(),
(namespace: Namespace) => {
if(!visitedNamespaceTbl[namespace.id]) {
if(namespace.doc) {
var transform = new this.construct(namespace.doc);
return(transform.exec(visitedNamespaceTbl, this.state));
}
}
return([]);
}
).then((outputList: Output[][]) => Array.prototype.concat.apply([output], outputList))));
}
.then((task) => {
if (task) {
return vol.unassignTask();
} else {
return Promise.resolve();
}
})
