new WebDriver.Session(webdriverOptions(navigator.browser, navigator.version, navigator.platform), function() {
var browser = this;
var resultStream = Bacon.fromArray(tests).flatMap(function(testCase) {
console.log(colors.green, "STARTING",formatResultName(navigator), testCase, colors.clear);
browser.url = "http://localhost:" + port + "/" + testCase + "?selenium";
var canvas = browser.element(".html2canvas", 15000);
var dataUrl = Bacon.constant(browser.execute(canvasToDataUrl, canvas));
var screenshot = Bacon.constant(browser.screenshot());
var result = dataUrl.flatMap(getPixelArray).combine(screenshot.flatMap(getPixelArray), calculateDifference);
console.log(colors.green, "COMPLETE", formatResultName(navigator), testCase, colors.clear);
return Bacon.combineTemplate({
browser: formatResultName(navigator),
testCase: testCase,
accuracy: result,
dataUrl: dataUrl,
screenshot: screenshot
});
});
if (fs.existsSync('tests/certificate.pem')) {
Bacon.combineWith(permissionRequest, drive, auth, Bacon.combineWith(uploadRequest, drive, auth, resultStream.doAction(mapResults).flatMap(createImages)).flatMap(executeRequest)).flatMap(executeRequestOriginal).onValue(uploadImages);
}
resultStream.onEnd(callback);
});
exports.list = function (req, res) {
var ids, noItems, keys, items;
ids = Bacon.fromNodeCallback(redis.lrange, itemsKey(req.query.tab), 0, -1);
noItems = ids.filter(isEmpty(true)).map([]);
keys = ids.filter(isEmpty(false)).map(_.partialRight(_.map, itemKey));
items = keys.map(Bacon.redis('mget'));
items.merge(noItems).respond(res);
};
function fetchVehicleId() {
if (cachedVehicleId) {
return Bacon.once(cachedVehicleId);
}
return Bacon.fromCallback(teslams.get_vid, TESLA_CREDENTIALS).doAction(function(vehicleId) {
console.log('Cached vehicle id ' + vehicleId);
cachedVehicleId = vehicleId;
});
}
.flatMap(function(result) {
return Bacon.combineTemplate({
browser: name,
testCase: testCase,
accuracy: Bacon.constant(result.dataUrl).flatMap(getPixelArray).combine(Bacon.constant(result.screenshot).flatMap(getPixelArray), calculateDifference),
dataUrl: result.dataUrl,
screenshot: result.screenshot
});
});
function webdriverStream(test) {
var browser = wd.remote("localhost", 4445, process.env.SAUCE_USERNAME, process.env.SAUCE_ACCESS_KEY);
var browserStream = new Bacon.Bus();
if (process.env.TRAVIS_JOB_NUMBER) {
test.capabilities["tunnel-identifier"] = process.env.TRAVIS_JOB_NUMBER;
test.capabilities["name"] = process.env.TRAVIS_COMMIT.substring(0, 10);
test.capabilities["build"] = process.env.TRAVIS_BUILD_NUMBER;
} else {
test.capabilities["name"] = "Manual run";
}
var resultStream = Bacon.fromNodeCallback(browser, "init", test.capabilities)
.flatMap(Bacon.fromNodeCallback(browser, "setImplicitWaitTimeout", 15000)
.flatMap(function() {
Bacon.later(0, formatResultName(test.capabilities)).onValue(browserStream.push);
return Bacon.fromArray(test.cases).zip(browserStream.take(test.cases.length)).flatMap(function(options) {
var testCase = options[0];
var name = options[1];
console.log(colors.green, "STARTING", name, testCase, colors.clear);
return Bacon.fromNodeCallback(browser, "get", "http://localhost:" + port + "/" + testCase + "?selenium")
.flatMap(Bacon.combineTemplate({
dataUrl: Bacon.fromNodeCallback(browser, "elementByCssSelector", ".html2canvas").flatMap(function(canvas) {
return Bacon.fromNodeCallback(browser, "execute", "return arguments[0].toDataURL('image/png').substring(22)", [canvas]);
}),
screenshot: Bacon.fromNodeCallback(browser, "takeScreenshot")
}))
.flatMap(function(result) {
return Bacon.combineTemplate({
browser: name,
testCase: testCase,
accuracy: Bacon.constant(result.dataUrl).flatMap(getPixelArray).combine(Bacon.constant(result.screenshot).flatMap(getPixelArray), calculateDifference),
dataUrl: result.dataUrl,
screenshot: result.screenshot
});
});
});
}));
resultStream.onError(function(error) {
var name = formatResultName(test.capabilities);
console.log(colors.red, "ERROR", name, error.message);
browserStream.push(name);
browser.quit();
});
resultStream.onValue(function(result) {
console.log(colors.green, "COMPLETE", result.browser, result.testCase, result.accuracy, "%", colors.clear);
browserStream.push(result.browser);
});
resultStream.onEnd(function() {
browser.quit();
});
return resultStream.fold([], pushToArray);
}
function createImages(data) {
var dataurlFileName = "tests/results/" + data.browser + "-" + data.testCase.replace(/\//g, "-") + "-html2canvas.png";
var screenshotFileName = "tests/results/" + data.browser + "-" + data.testCase.replace(/\//g, "-") + "-screencapture.png";
return Bacon.combineTemplate({
name: data.testCase,
dataurl: Bacon.fromNodeCallback(fs.writeFile, dataurlFileName, data.dataUrl, "base64").map(function() {
return dataurlFileName;
}),
screenshot: Bacon.fromNodeCallback(fs.writeFile, screenshotFileName, data.screenshot, "base64").map(function() {
return screenshotFileName;
})
});
}
function runWebDriver(browsers, cases) {
var availableBrowsers = new Bacon.Bus();
var result = Bacon.combineTemplate({
capabilities: Bacon.fromArray(browsers).zip(availableBrowsers.take(browsers.length), function(first) { return first; }),
cases: cases
}).flatMap(webdriverStream).doAction(function() {
availableBrowsers.push("ready");
});
Bacon.fromArray([1, 2, 3, 4]).onValue(availableBrowsers.push);
return result.fold([], pushToArray);
}
function initialize() {
logEmitter = new events.EventEmitter();
module.exports.logStream = Bacon.fromEvent(logEmitter, constants.eventStreams.LOGGING);
characterEventEmitter = new events.EventEmitter();
module.exports.characterEventStream = Bacon.fromEvent(characterEventEmitter, constants.eventStreams.CHARACTEREVENT);
inputEmitter = new events.EventEmitter();
module.exports.inputStream = Bacon.fromEvent(inputEmitter, constants.eventStreams.INPUT);
gameEventEmitter = new events.EventEmitter();
module.exports.gameEventStream = Bacon.fromEvent(gameEventEmitter, constants.eventStreams.GAMEEVENT);
}
function runWebDriver(cases) {
var availableBrowsers = new Bacon.Bus();
var browsers = [
{
browserName: "chrome",
platform: "Windows 7",
version: "34"
},{
browserName: "firefox",
version: "15",
platform: "Windows 7"
},{
browserName: "internet explorer",
version: "9",
platform: "Windows 7"
},{
browserName: "internet explorer",
version: "10",
platform: "Windows 8"
},{
browserName: "internet explorer",
version: "11",
platform: "Windows 8.1"
},{
browserName: "safari",
version: "6",
platform: "OS X 10.8"
},{
browserName: "safari",
platform: "OS X 10.9",
version: "7"
},{
browserName: "chrome",
platform: "OS X 10.8",
version: "34"
}
];
var result = Bacon.combineTemplate({
capabilities: Bacon.fromArray(browsers).zip(availableBrowsers.take(browsers.length), function(first) { return first; }),
cases: cases
}).flatMap(webdriverStream).doAction(function() {
availableBrowsers.push("ready");
});
Bacon.fromArray([1, 2, 3, 4]).onValue(availableBrowsers.push);
return result.fold([], pushToArray);
}
function runWebDriver() {
var browsers = [
{
browser: "chrome",
platform: "Windows 7"
},{
browser: "firefox",
version: "15",
platform: "Windows 7"
},{
browser: "internet explorer",
version: "9",
platform: "Windows 7"
},{
browser: "internet explorer",
version: "10",
platform: "Windows 8"
},{
browser: "safari",
version: "6",
platform: "OS X 10.8"
},{
browser: "chrome",
platform: "OS X 10.8"
}
];
var testRunnerStream = Bacon.sequentially(1000, browsers).flatMap(webdriverStream);
testRunnerStream.onEnd(writeResults);
testRunnerStream.onEnd(closeServer);
}
var resultStream = Bacon.fromArray(tests).flatMap(function(testCase) {
console.log(colors.green, "STARTING",formatResultName(navigator), testCase, colors.clear);
browser.url = "http://localhost:" + port + "/" + testCase + "?selenium";
var canvas = browser.element(".html2canvas", 15000);
var dataUrl = Bacon.constant(browser.execute(canvasToDataUrl, canvas));
var screenshot = Bacon.constant(browser.screenshot());
var result = dataUrl.flatMap(getPixelArray).combine(screenshot.flatMap(getPixelArray), calculateDifference);
console.log(colors.green, "COMPLETE", formatResultName(navigator), testCase, colors.clear);
return Bacon.combineTemplate({
browser: formatResultName(navigator),
testCase: testCase,
accuracy: result,
dataUrl: dataUrl,
screenshot: screenshot
});
});
var updateNickname = connections.flatMap(function(socket) {
return Bacon.fromBinder(function(sink) {
socket.on('nickname', function(txt) {
sink({ author: socket, nickname: txt });
});
});
});
var disconnections = connections.flatMap(function(socket) {
return Bacon.fromBinder(function(sink) {
socket.on('disconnect', function(txt) {
sink(socket);
});
});
});
resultsForPage: function(page) {
// We're basically ignoring 'page' and assuming it's increasing
// by 1 every time we're called, which violates our abstraction
// but is actually consistent with the way we're using the interface.
return Bacon.fromCallback(function(cb) {
$.getJSON(exports.getSearchURL({
pageToken: nextPageToken,
q: q
}), function(results) {
nextPageToken = results.nextPageToken;
cb({
morePagesLeft: !!results.nextPageToken,
posts: results.items.map(function(result) {
return {
title: _.escape(result.snippet.title),
excerpt: _.escape(result.snippet.description),
pubdate: new Date(result.snippet.publishedAt),
thumbnail: {
url: result.snippet.thumbnails.medium.url,
width: 320,
height: 180
},
isVideo: true,
link: 'http://youtube.com/watch?v=' + result.id.videoId
};
})
});
});
});
}
var messages = connections.flatMap(function(socket) {
return Bacon.fromBinder(function(sink) {
socket.on('message', function(txt) {
sink({ author: socket, txt: txt });
});
});
});
beforeEach(() => {
stream = Bacon.fromBinder(function (_sink) {
sink = _sink;
});
onAlert = jasmine.createSpy();
});
exports.setup = function() {
$('<link rel="stylesheet/less" href="/less/styles.less">')
.prependTo('head');
window.less = {
strictMath: true
};
Bacon.fromArray(SCRIPTS).flatMap(function(script) {
return Bacon.fromPromise($.getScript(script));
}).onEnd(function() {
$('link[href$="styles.css"]').remove();
// Undo our default border-box sizing for dat.gui, as it expects
// the W3C-defined default (content-box).
$('<style>body > div.dg * {' +
'box-sizing: content-box; -moz-box-sizing: content-box; ' +
'-webkit-box-sizing: content-box; }</style>').appendTo('head');
var gui = new dat.GUI();
var obj = {};
Object.keys(COLOR_VARS).forEach(function(varName) {
obj[varName] = COLOR_VARS[varName];
gui.addColor(obj, varName).onChange(function(value) {
var vars = {};
vars[varName] = value;
less.modifyVars(vars);
});
});
});
};
function blankResults() {
return Bacon.once({
morePagesLeft: false,
page: 1,
pages: 1,
posts: []
});
}
var updateDriveStateJob = new CronJob('* * * * *', function(){
var driveState = Bacon.retry({source: tesla.driveState,
retries: 3,
delay: function(){return 5000;}});
driveState.onError(function(error) {
console.error("Error fetching driveState:", error);
});
driveState.onValue(saveDriveState);
});
return Bacon.combineAsArray(requests.map(function(request) {
return Bacon.fromCallback(function(callback) {
request.execute(function(err, result) {
if (!err) {
callback(request.fileData);
} else {
console.log("Google drive error", err);
}
});
});
}));
return Bacon.fromArray(test.cases).zip(browserStream.take(test.cases.length)).flatMap(function(options) {
var testCase = options[0];
var name = options[1];
console.log(colors.green, "STARTING", name, testCase, colors.clear);
return Bacon.fromNodeCallback(browser, "get", "http://localhost:" + port + "/" + testCase + "?selenium")
.flatMap(Bacon.combineTemplate({
dataUrl: Bacon.fromNodeCallback(browser, "elementByCssSelector", ".html2canvas").flatMap(function(canvas) {
return Bacon.fromNodeCallback(browser, "execute", "return arguments[0].toDataURL('image/png').substring(22)", [canvas]);
}),
screenshot: Bacon.fromNodeCallback(browser, "takeScreenshot")
})).flatMap(function(result) {
return Bacon.combineTemplate({
browser: name,
testCase: testCase,
accuracy: Bacon.constant(result.dataUrl).flatMap(getPixelArray).combine(Bacon.constant(result.screenshot).flatMap(getPixelArray), calculateDifference),
dataUrl: result.dataUrl,
screenshot: result.screenshot
});
});
});
}).flatMap(function (msg) {
return Bacon.fromArray([
{
type: 'course',
heading: msg.trackTrue},
{
type: 'speed',
knots: msg.speedKnots
}
]);
}));
resultsForPage: function(page) {
return Bacon.fromCallback(function(cb) {
$.getJSON('/api/page/about', function(info) {
cb({
page: 1,
pages: 1,
pageInfo: info
});
});
});
},
function httpget(options) {
return Bacon.fromCallback(function(callback) {
https.get(options, function(res){
var data = '';
res.on('data', function (chunk){
data += chunk;
});
res.on('end',function(){
callback(data);
});
});
});
}
mediator.getEventStream = function (eventName) {
var event, result;
// If we don't specify the event then return Bus with all events
if (typeof eventName === 'undefined') {
result = this.bacon.bus;
} else {
event = this.bacon.event[eventName];
if (typeof event !== 'undefined') {
result = event._eventStream;
} else {
// if we don't have such event then we return ended EventStream
result = Bacon.never();
}
}
return result;
};
}).flatMap(function (msg) {
return Bacon.fromArray([
{
type: 'course',
heading: msg.trackTrue},
{
type: 'speed',
knots: msg.speedKnots
},
{
type: 'position',
lat: Number(msg.lat.substring(0, 2)) + Number(msg.lat.substring(2, msg.lat.length)) / 60,
lon: Number(msg.lon.substring(0, 3)) + Number(msg.lon.substring(3, msg.lon.length) / 60)
}
]);
}));
exports.create = function (req, res) {
var inputData, id, data, create, addToList;
inputData = extractFields(req.body);
id = Bacon.fromNodeCallback(redis.incr, freeItemKey());
data = id.map(function(id) { inputData.id = id; return inputData; });
create = Bacon.combineAsArray(
id.map(itemKey), data.map(JSON.stringify)
).map(Bacon.redis('set'));
itemsKey = data.map('.tabId').map(itemsKey);
addToList = Bacon.combineAsArray(itemsKey, id).map(Bacon.redis('set'));
Bacon.combineWith([data, create, addToList], fst).respond(res);
};
beforeEach(function() {
scope = {
$apply: function(f) {
f(scope);
},
$on: function() {
},
filterChanges: new Bacon.Property(),
addFilter: sinon.stub()
};
kenobi = {
getFooRequest: sinon.stub()
};
filteredKenobi = {
syncList: sinon.stub()
.withArgs(scope.filterChanges, kenobi.getFooRequest)
.returns(Bacon.once(newResults))
};
});
subscribe: function (eventName, cb) {
var bacon = this.bacon,
event;
// If we don't have this event then create it
if (typeof bacon.event[eventName] === 'undefined') {
bacon.event[eventName] = {
_eventStream:
Bacon.fromEvent(this, 'publish', function (eventEventName, eventValue) {
var result = null;
// transforming to one object
// We need event to filter it
// Then we will take only value
if (eventValue instanceof Message) {
result = {
event: eventEventName,
value: eventValue.getData()
}
}
return result;
})
.filter(function (e) {
return e.event === eventName;
}).map('.value')
// we need only value
.name(eventName),
_unsubscribers: {}
};
bacon.bus.plug(bacon.event[eventName]._eventStream);
}
event = bacon.event[eventName];
// Subscribe cb to the stream and save unsubscribe hook
event._unsubscribers[cb] = event._eventStream.onValue(function (val) {
cb(val);
});
},
var clients = {};
var counter = 1;
app.get('/chat', function(req, res) {
res.sendFile('/Users/gabriel.sobral/Desktop/test_nodejs/chat/index.html');
});
http.listen(3000, function(){
console.log(new Date(), 'listening on *:3000');
});
// ********************************************************************
var connections = Bacon.fromBinder(function(sink) {
io.on('connection', sink);
});
var disconnections = connections.flatMap(function(socket) {
return Bacon.fromBinder(function(sink) {
socket.on('disconnect', function(txt) {
sink(socket);
});
});
});
var messages = connections.flatMap(function(socket) {
return Bacon.fromBinder(function(sink) {
socket.on('message', function(txt) {
sink({ author: socket, txt: txt });
});