moixal/projecte_ionic
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Conexio amb la api

Browse source
This commit is contained in:
janmaroto 2022-02-09 18:30:03 +01:00
commit b12369cb47
48513 changed files with 7391639 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

352
node_modules/browserstack/test/api.js generated vendored Executable file
View file

@ -0,0 +1,352 @@
"use strict";
var should = require("should");
var BrowserStack = require("../lib/browserstack");
var util = require("./util");
var username = util.browserStack.username;
var password = util.browserStack.password;
if (!username || !password) {
throw new Error("Please set BROWSERSTACK_USERNAME and BROWSERSTACK_KEY environment variables.");
}
describe("BrowserStack API", function() {
this.timeout(60000); // 60s
var client;
var workers = [];
beforeEach(function() {
client = BrowserStack.createClient({
username: username,
password: password
});
});
afterEach(function(done) {
util.terminateWorkers(client, workers, function() {
workers = [];
done();
});
});
describe("API Status", function() {
it("should get API status", function(done) {
client.getApiStatus(function(err, status) {
should.ifError(err);
status.should.be.an.Object().and.have.keys([
"running_sessions",
"sessions_limit",
"used_time",
"total_available_time"
]);
done(err);
});
});
});
describe("Browser Listing", function() {
it("should list browsers", function(done) {
client.getBrowsers(function(err, browsers) {
should.ifError(err);
browsers.should.be.an.Array().and.not.be.empty();
browsers.map(util.validateBrowserObject);
done(err);
});
});
it("should get latest browser versions", function(done) {
client.getLatest(function(err, versions) {
should.ifError(err);
versions.should.be.an.Object().and.not.be.empty();
done(err);
});
});
it("should get the latest version for specified browser", function(done) {
client.getBrowsers(function(err, browsers) {
should.ifError(err);
browsers = browsers.filter(function(browser) {
return !browser.device;
});
var requests = browsers.length;
browsers.forEach(function(browser) {
client.getLatest(browser, function(err, version) {
should.ifError(err);
version.should.match(/\d+(\.)*\d*/);
if (err || --requests < 1) {
if (done) {
done(err);
done = null;
}
}
});
});
});
});
it("should fail to get the latest version for invalid browser", function(done) {
client.getLatest({
os: "Windows",
os_version: "10",
browser: "mosaic"
}, function(err, version) {
should.ifError(err);
should.equal(undefined, version);
done(err);
});
});
});
describe("Worker API", function() {
var sampleDesktopBrowser = {
os: "Windows",
os_version: "10",
browser: "chrome",
browser_version: "47.0",
timeout: 20
};
var sampleDeviceBrowser = {
device: "Google Nexus 6",
os: "android",
os_version: "5.0",
browser: "Android Browser",
timeout: 20
};
it("should create worker", function(done) {
client.createWorker(util.merge(sampleDesktopBrowser, {
url: "http://www.example.com"
}), function(err, worker) {
should.ifError(err);
util.validateWorker(worker);
workers.push(worker);
done(err);
});
});
it("should create worker with latest edge", function(done) {
client.createWorker({
os: "Windows",
os_version: "10",
browser: "Edge",
browser_version: "latest",
url: "http://www.example.com",
timeout: 20
}, function(err, worker) {
should.ifError(err);
util.validateWorker(worker);
workers.push(worker);
done(err);
});
});
it("should fail to create worker for invalid browser", function(done) {
client.createWorker(util.merge(sampleDesktopBrowser, {
url: "http://www.example.com",
browser: "mosaic"
}), function(err, worker) {
err.should.be.an.Error();
err.message.should.match(/validation failed/i);
should.not.exist(worker);
done();
});
});
it("should create a worker with details", function(done) {
client.createWorker(util.merge(sampleDesktopBrowser, {
url: "http://www.example.com",
name: "worker-1",
build: "build-1",
project: "project-1"
}), function(err, worker) {
should.ifError(err);
util.validateWorker(worker);
workers.push(worker);
done(err);
});
});
it("should create a worker for a device browser", function(done) {
client.createWorker(util.merge(sampleDeviceBrowser, {
url: "http://www.example.com"
}), function(err, worker) {
should.ifError(err);
util.validateWorker(worker);
workers.push(worker);
done(err);
});
});
it("should fail to create worker for invalid device", function(done) {
client.createWorker(util.merge(sampleDeviceBrowser, {
url: "http://www.example.com",
device: "Nexus 5S"
}), function(err, worker) {
err.should.be.an.Error();
err.message.should.match(/validation failed/i);
should.not.exist(worker);
done();
});
});
it("should get created worker by id", function(done) {
client.createWorker(util.merge(sampleDeviceBrowser, {
url: "http://www.example.com"
}), function(err, worker) {
should.ifError(err);
util.validateWorker(worker);
workers.push(worker);
client.getWorker(worker.id, function(err, worker2) {
should.ifError(err);
util.validateWorker(worker2);
should.equal(worker.id, worker2.id, "Worker id mismatch");
done(err);
});
});
});
it("should fetch list of workers", function(done) {
client.createWorker(util.merge(sampleDeviceBrowser, {
url: "http://www.example.com"
}), function(err, worker) {
should.ifError(err);
util.validateWorker(worker);
workers.push(worker);
client.getWorkers(function(err, workers) {
should.ifError(err);
workers.should.be.an.Array().and.not.be.empty();
var workerExists = workers.filter(function(w) {
util.validateWorker(w);
return (w.id === worker.id);
}).shift();
done(workerExists ? null : new Error("failed to fetch created worker"));
});
});
});
it("should terminate a worker by id", function(done) {
client.createWorker(util.merge(sampleDeviceBrowser, {
url: "http://www.example.com"
}), function(err, worker) {
should.ifError(err);
util.validateWorker(worker);
workers.push(worker);
client.terminateWorker(worker.id, function(err, data) {
should.ifError(err);
data.should.be.an.Object();
data.time.should.match(/\d+/);
done(err);
});
});
});
});
describe("Worker Session APIs", function() {
this.timeout(100000);
var sampleDesktopBrowser = {
os: "Windows",
os_version: "10",
browser: "chrome",
browser_version: "47.0",
timeout: 120
};
it("should change worker url", function(done) {
client.createWorker(util.merge(sampleDesktopBrowser, {
url: "http://www.example.com"
}), function(err, worker) {
should.ifError(err);
util.validateWorker(worker);
workers.push(worker);
util.pollApiWorker(client, worker, function(err, isRunning) {
if (isRunning) {
return client.changeUrl(worker.id, {
url: "http://www.example.net",
timeout: 20
}, function(err, data) {
should.ifError(err);
data.should.be.an.Object();
data.message.should.match(/browser updated with new url/i);
done(err);
});
}
should.ifError(err);
return done(err || new Error("worker remained in queue until timeout"));
});
});
});
it("should take screenshot of worker session", function(done) {
client.createWorker(util.merge(sampleDesktopBrowser, {
url: "http://www.example.com"
}), function(err, worker) {
should.ifError(err);
util.validateWorker(worker);
workers.push(worker);
util.pollApiWorker(client, worker, function(err, isRunning) {
if (isRunning) {
// wait for page load
var pageLoadTime = 5000;
return setTimeout(function() {
client.takeScreenshot(worker.id, function(err, data) {
should.ifError(err);
data.should.be.an.Object();
data.url.should.match(/^http(s)?:\/\/.*\.png$/i);
done(err);
});
}, pageLoadTime);
}
should.ifError(err);
return done(err || new Error("worker remained in queue until timeout"));
});
});
});
});
});

76
node_modules/browserstack/test/client.js generated vendored Executable file
View file

@ -0,0 +1,76 @@
"use strict";
var assert = require("assert");
var BrowserStack = require("../lib/browserstack");
var util = require("./util");
var apiLatestVersion = 4;
var username = util.browserStack.username;
var password = util.browserStack.password;
if (!username || !password) {
throw new Error("Please set BROWSERSTACK_USERNAME and BROWSERSTACK_KEY environment variables.");
}
describe("Public API", function() {
it("exposes API and Screenshots clients", function() {
[
"createClient",
"createScreenshotClient"
].forEach(function(fn) {
assert.equal("function", typeof BrowserStack[fn]);
});
});
describe("new ApiClient", function() {
var className = "ApiClient";
it("should return an API client", function() {
var client = BrowserStack.createClient({
username: username,
password: password
});
assert.equal(className, client.constructor.name, "instance of " + className);
});
it("should return an API client of a particular version", function() {
for (var version = 1; version <= apiLatestVersion; version++) {
var client = BrowserStack.createClient({
username: username,
password: password,
version: version
});
assert.equal(className, client.constructor.name, "instance of ApiClient");
assert.equal(version, client.version, "ApiClient version mismatch");
}
});
it("should throw an error for invalid ApiClient version", function() {
try {
BrowserStack.createClient({
username: username,
password: password,
version: -1
});
} catch (err) {
assert.ok(err.toString().match(/invalid version/i));
}
});
});
describe("new ScreenshotClient", function() {
var className = "ScreenshotClient";
it("should return a screenshot client", function() {
var client = BrowserStack.createScreenshotClient({
username: username,
password: password
});
assert.equal(className, client.constructor.name, "instance of " + className);
});
});
});

95
node_modules/browserstack/test/screenshot.js generated vendored Executable file
View file

@ -0,0 +1,95 @@
"use strict";
var should = require("should");
var BrowserStack = require("../lib/browserstack");
var util = require("./util");
var username = util.browserStack.username;
var password = util.browserStack.password;
if (!username || !password) {
throw new Error("Please set BROWSERSTACK_USERNAME and BROWSERSTACK_KEY environment variables.");
}
describe("Screenshot API", function() {
this.timeout(300000); // 300s
var client;
beforeEach(function() {
client = BrowserStack.createScreenshotClient({
username: username,
password: password
});
});
it("should list browsers", function(done) {
client.getBrowsers(function(err, browsers) {
should.ifError(err);
browsers.should.be.an.Array().and.not.be.empty();
browsers.map(util.validateBrowserObject);
done(err);
});
});
it("should generate screenshots for multiple browsers", function(done) {
var options = {
url: "http://www.example.com",
browsers: ["40.0", "41.0", "42.0"].map(function(v) {
return {
os: "Windows",
os_version: "7",
browser: "chrome",
browser_version: v
};
})
};
client.generateScreenshots(options, function(err, job) {
should.ifError(err);
util.validateScreenshotJob(job);
util.pollScreenshotWorker(client, job, function(err, isRunning) {
if (!err && !isRunning) {
// this is highly dependent on demand and queue time at BrowserStack;
// little point in stalling the test run waiting for this job to complete
// print warning in console for user to decide
console.warn("\t[WARN] worker %s did not run within timeout", job.job_id);
}
done(err);
});
});
});
it("should fetch a screenshot job", function(done) {
var options = {
url: "http://www.example.com",
browsers: [
{
os: "Windows",
os_version: "7",
browser: "chrome",
browser_version: "42.0"
}
]
};
client.generateScreenshots(options, function(err, job) {
should.ifError(err);
util.validateScreenshotJob(job);
client.getJob(job.job_id, function(err, job) {
if (!err) {
util.validateScreenshotJob(job);
}
done(err);
});
});
});
});

134
node_modules/browserstack/test/util.js generated vendored Executable file
View file

@ -0,0 +1,134 @@
"use strict";
var extend = require("../lib/extend");
var pollWorkerRetries = 30;
var pollWorkerRetryInterval = 2000;
var encoding = process.env.TRAVIS ? "base64" : "utf8";
module.exports.browserStack = {
username: Buffer.from(process.env.BROWSERSTACK_USERNAME || "", encoding).toString(),
password: Buffer.from(process.env.BROWSERSTACK_KEY || "", encoding).toString()
};
module.exports.terminateWorkers = function terminateWorkers(client, workers, callback) {
if (!workers.length) {
return callback(null);
}
if (workers[0].id) {
workers = workers.map(function(w) {
return w.id;
});
}
client.terminateWorker(workers.shift(), function() {
if (!workers.length) {
return callback(null);
}
terminateWorkers(client, workers, callback);
});
};
module.exports.pollApiWorker = function pollApiWorker(client, worker, callback) {
pollWorker(worker,
client.getWorker.bind(client),
function getWorkerId(worker) {
return worker && worker.id;
},
function isWorkerRunning(worker) {
return worker && worker.status === "running";
}, callback);
};
module.exports.pollScreenshotWorker = function pollScreenshotWorker(client, worker, callback) {
pollWorker(worker,
client.getJob.bind(client),
function getWorkerId(worker) {
return worker && (worker.job_id || worker.id);
},
function isWorkerRunning(worker) {
return worker && worker.state === "running";
}, callback);
};
module.exports.validateBrowserObject = function validateBrowserObject(browser) {
[
"os",
"os_version",
"browser",
browser.device ? "device" : "browser_version"
].forEach(function(attr) {
if (attr.match(/version/)) {
browser[attr].should.be.a.String().and.match(/\S+/);
} else {
browser[attr].should.be.a.String().and.match(/^[a-zA-Z]+/);
}
});
return browser;
};
module.exports.validateScreenshotJob = function validateScreenshotJob(job) {
job.should.be.an.Object().and.not.be.empty();
(job.job_id || job.id).should.match(/[a-zA-Z0-9]+/);
[
"quality",
"win_res",
"wait_time"
].forEach(function(k) {
job.should.have.property(k);
});
job.screenshots
.map(this.validateBrowserObject)
.forEach(function(screenshotState) {
screenshotState.id.should.match(/[a-zA-Z0-9]+/);
["processing", "pending", "queue", "running"].should.containEql(screenshotState.state);
});
};
module.exports.validateWorker = function validateWorker(w) {
w.should.be.an.Object();
w.id.should.match(/\d+/);
return w;
};
module.exports.merge = function merge(o, a) {
return extend(extend({}, o), a);
};
function pollWorker(worker, getWorkerStatusFn, getWorkerIdFn, isWorkerRunningFn, callback) {
var maxRetries = pollWorkerRetries;
var retryInterval = pollWorkerRetryInterval;
var workerId = getWorkerIdFn(worker);
var timer;
var pollWorkerState = function(id, callback) {
if (--maxRetries < 1) {
clearTimeout(timer);
return callback(null, false);
}
getWorkerStatusFn(workerId, function(err, worker) {
workerId = getWorkerIdFn(worker);
if (err || !workerId) {
clearTimeout(timer);
return callback(err, false);
}
if (isWorkerRunningFn(worker)) {
return callback(null, true);
}
setTimeout(function() {
pollWorkerState(id, callback);
}, retryInterval);
});
};
pollWorkerState(workerId, callback);
}