test('testName2', async t => {
await delay(1000);
console.log('bar');
await delay(2000);
console.log('quz');
t.pass();
});
bot.command('!raffle open', { rank: 'mod' }, async (message, price, maxTickets, winners = 1) => {
if (!bot.florins) {
throw new Error(
'The raffle depends on the florins module, but it doesn\'t appear to be available.')
}
if (bot.raffle) {
throw new Error('Another raffle is already open.')
}
if (!check(price) || price < 0) {
throw new Error(`Given ticket price is not valid. (${openUsage})`)
}
if (!check(maxTickets) || maxTickets < 0) {
throw new Error(`Given maximum number of tickets is not valid. (${openUsage})`)
}
if (!check(winners) || winners < 0) {
throw new Error(`Given number of winners is not valid. (${openUsage})`)
}
bot.raffle = raffle(bot, price, maxTickets, winners)
bot.send(
`Raffle opened! Tickets cost ${price} florins, ` +
`and you can buy a maximum of ${maxTickets} tickets.`
)
const example = `!ticket ${Math.floor((Math.random() * maxTickets) + 1)}`
await delay(100)
bot.send(`Use "!ticket [number of tickets]" (e.g. "${example}") to participate!`)
await delay(100)
bot.send('Use "!ticket clear" to cancel your participation.')
})
const start = async () => {
let request = require('request');
const d = require('delay');
await d(1000);
var fs = require('fs');
var array = fs.readFileSync('CUI.txt').toString().split("\r\n");
var start=0;
while(start<array.length){
var nr = Math.floor(Math.random() * Math.floor(495))+1;
var jsonData=[];
console.log('start at ' + start+ ' for nr ' + nr);
var i=0;
while(i<nr && i+start<array.length){
jsonData.push({"cui": array[i+start], "data":"2018-03-26"});
i++;
}
var finish=false;
console.log('array :'+ jsonData[0].cui + '-' + jsonData[nr-1].cui);
request.post(
'https://webservicesp.anaf.ro/PlatitorTvaRest/api/v3/ws/tva',
{ json: jsonData },
function (error, response, body) {
finish=true;
if (!error && response.statusCode == 200) {
console.log(body);
fs.writeFile(`text${start}_${nr}.json`, JSON.stringify( body ), function (err) {
if (err) {
return console.log(err);
}
console.log("The file was saved!" + `text${start}_${nr}.json`);
});
}
});
start = start+nr;
while(!finish){
console.log('waiting');
await d(13000);
}
}
console.log('finish')
return;
request.post(
'https://webservicesp.anaf.ro/PlatitorTvaRest/api/v3/ws/tva',
{ json: [{"cui": 6194577, "data":"2018-03-26"}] },
function (error, response, body) {
if (!error && response.statusCode == 200) {
console.log(body)
}
}
);
}
test('testName2', async t => {
await delay(1000);
process.stdout.write('bar ');
await delay(2000);
process.stdout.write('quz ');
await delay(1000);
t.pass();
});
return async function (t) {
await delay(200);
const len = Math[even ? 'floor' : 'ceil']((process.stdout.columns + adjust) / 2);
for (let i = 0; i < len; i++) {
process.stdout.write(String(i % 10));
await delay(1); // eslint-disable-line no-await-in-loop
}
await delay(200);
t.pass();
};
return async function (t) {
await delay(200);
var len = Math[even ? 'floor' : 'ceil']((process.stdout.columns + adjust) / 2);
for (var i = 0; i < len; i++) {
process.stdout.write(String(i % 10));
await delay(1);
}
await delay(200);
t.pass();
};
cabal.on('peer-added', (key) => {
console.log( "Peer added", key );
delay( 2000 ).then( () => {
console.log( "Quitting 2 seconds after peer connect" )
process.exit(0)
})
})
}).catch((error) => {
delay(1000).then(() => {
_registerServiceInDirectory(runnableService, serverPort, directoryLocation);
});
const logger = loggerManager.getLogger('ServiceDirectoryProxy');
logger.warn('Retrying to register service %s in directory \'%s\', because %s -> %s.', runnableService.getIdentificationName(), directoryLocation, error.code, error.message);
});
const Excute = async function(User, TargetUsername, Text, sleep, mysyntx){
try {
/** TRY TO LOGIN **/
console.log('\n');
console.log('[?] Try to Login . . .');
const doLogin = await Login(User);
console.log(chalk`{bold.green [!] Login Succsess!}`);
/** TRY TO GET ALL MEDIA **/
console.log('[?] Try to get Media . . .')
const getTarget = await Target(TargetUsername);
var getMedia = await Media(doLogin.session, getTarget.id);
console.log(chalk`{bold.green [!] Succsess to get Media From [${TargetUsername}] }\n`);
getMedia = _.chunk(getMedia, mysyntx);
/** TRY TO DELETE ALL MEDIA **/
for (let i = 0; i < getMedia.length; i++) {
console.log('[?] Try to Like Photo/Delay \n')
await Promise.all(getMedia[i].map(async(media) => {
var ranText = Text[Math.floor(Math.random() * Text.length)];
const ngeDo = await ngeComment(doLogin.session, media.id, ranText)
const PrintOut = chalk`${ngeDo ? chalk`{bold.green Sukses Komen}` : chalk`{bold.red Gagal Komen}`}`
console.log(chalk`> ${media.link} => ${PrintOut} [${ranText}]`);
}))
console.log(chalk`{yellow \n [#][>] Delay For ${sleep} MiliSeconds [<][#] \n}`)
await delay(sleep)
}
console.log(chalk`{bold.green [+] Bom Komen Post Succsess}`)
} catch (err) {
console.log(err);
}
}
downloadManager.addTaskList(listTask).then(() => {
delay(300)
.then(() => {
eventEmitter.emit('theme:download:finish');
resolve();
});
})
it('should allow ceil\'ed second precision mtime', async () => {
fs.writeFileSync(`${tmpDir}/foo`, '');
const customFs = {
...fs,
stat(path, cb) {
fs.stat(path, (err, stat) => {
if (err) {
return cb(err);
}
// Make second precision if not already
stat.mtime = new Date(Math.ceil(stat.mtime.getTime() / 1000) * 1000);
cb(null, stat);
});
},
};
await lockfile.lock(`${tmpDir}/foo`, {
fs: customFs,
update: 1000,
});
await pDelay(3000);
});
it('should allow millisecond precision mtime', async () => {
fs.writeFileSync(`${tmpDir}/foo`, '');
const customFs = {
...fs,
stat(path, cb) {
fs.stat(path, (err, stat) => {
if (err) {
return cb(err);
}
stat.mtime = new Date((Math.floor(stat.mtime.getTime() / 1000) * 1000) + 123);
cb(null, stat);
});
},
};
const dateNow = Date.now;
jest.spyOn(Date, 'now').mockImplementation(() => (Math.floor(dateNow() / 1000) * 1000) + 123);
await lockfile.lock(`${tmpDir}/foo`, {
fs: customFs,
update: 1000,
});
await pDelay(3000);
});
it('should call the compromised function if lock was acquired by someone else due to staleness', async () => {
fs.writeFileSync(`${tmpDir}/foo`, '');
const customFs = { ...fs };
const deferred = pDefer();
const handleCompromised = (err) => {
expect(err.code).toBe('ECOMPROMISED');
expect(fs.existsSync(`${tmpDir}/foo.lock`)).toBe(true);
deferred.resolve();
};
await lockfile.lock(`${tmpDir}/foo`, {
fs: customFs,
update: 1000,
stale: 3000,
onCompromised: handleCompromised,
});
customFs.utimes = (path, atime, mtime, callback) => setTimeout(() => callback(new Error('foo')), 6000);
await pDelay(4500);
await lockfile.lock(`${tmpDir}/foo`, { stale: 3000 });
await deferred.promise;
}, 10000);
it('should always rerender if pure:false was specified', () => {
const pending = sinon.stub().returns(null);
const Wrapped = resolver({
1: () => delay(10, 1),
2: () => delay(20, 2),
3: () => delay(30, 3)
}, undefined, undefined, {
pure: false
})(() => null, undefined, pending);
const store = makeStore();
const component = (
<Provider store={store}>
<Wrapped params={{}} />
</Provider>
);
TestUtils.renderIntoDocument(component);
return delay(40).then(() => {
// initial rendering + 1 on each resolve
pending.args.should.have.length(3 + 1);
});
});
it('should restart when params changed', done => {
const store = createStore(combineReducers({
resolver: reducer,
params: (state = { id: 1 }, action = {}) => {
const { type } = action;
switch (type) {
case 'params/update':
return { id: state.id + 1 };
default: return state;
}
}
}), { resolver: {}, params: {} });
const stub1 = sinon.stub().returns(Promise.resolve(1));
const stub2 = sinon.stub().returns(Promise.resolve(2));
const wait = delay(10);
const Wrapped = resolver({
stub1,
stub2
})(Debug);
class Wrapper extends Component {
static propTypes = {
dispatch: PropTypes.func,
params: PropTypes.any
};
componentDidMount() {
wait.then(() => {
this.props.dispatch({
type: 'params/update'
});
});
}
render() {
const { params } = this.props;
return <Wrapped params={params} />;
}
}
const SubscribedWrapper = connect(state => ({
params: state.params
}))(Wrapper);
const component = (
<Provider store={store}>
<SubscribedWrapper />
</Provider>
);
TestUtils.renderIntoDocument(component);
wait().then(() => delay(10)).then(() => {
stub1.calledTwice.should.be.true;
stub2.calledTwice.should.be.true;
done();
});
});
.catch(err => {
if (err.retryable === true && retry < 10) {
return delay(2000).then(() => this._exec(method, params, retry + 1));
}
throw err;
});
ava(function (a) {
a.plan(2);
a.throws(delay.reject(10, new Error('foo')), 'foo');
a.notThrows(delay(20).then(function () {
asyncCalled = true;
}));
}).run().then(function (result) {
it('should set a flush timeout', function(done) {
var flushed = false;
subscriber.flushQueues_ = function() {
flushed = true;
};
var delayPromise = delay(0);
var fakeBoundDelay = function() {};
delayPromise.cancel.bind = function(context) {
assert.strictEqual(context, delayPromise);
return fakeBoundDelay;
};
delayOverride = function(timeout) {
assert.strictEqual(timeout, 1000);
return delayPromise;
};
var promise = subscriber.setFlushTimeout_();
promise.then(function() {
assert.strictEqual(subscriber.flushTimeoutHandle_, promise);
assert.strictEqual(promise.cancel, fakeBoundDelay);
assert.strictEqual(flushed, true);
done();
});
});
ava(function (a) {
a.plan(6);
for (var i = 0; i < 3; ++i) {
a.throws(delay.reject(10, new Error('foo')), 'foo');
a.notThrows(delay(10), 'foo');
}
}).run().then(function (result) {
const Excute = async function(User, TargetUsername, Text, Sleep, mysyntx){
try {
console.log(chalk`{yellow \n [?] Try to Login . . .}`)
const doLogin = await Login(User);
console.log(chalk`{green [!] Login Succsess, }{yellow [?] Try To Get Link & Media ID Target . . .}`)
const getTarget = await Target(TargetUsername);
console.log(chalk`{green [!] ${TargetUsername} [${getTarget}]}`);
const getFollowers = await Followers(doLogin.session, doLogin.account.id);
console.log(chalk`{cyan [?] Try to Follow, Comment, and Like Followers Target . . . \n}`)
var TargetResult = await Client.Media.likers(doLogin.session, getTarget);
TargetResult = _.chunk(TargetResult, mysyntx);
for (var i = 0; i < TargetResult.length; i++) {
var timeNow = new Date();
timeNow = `${timeNow.getHours()}:${timeNow.getMinutes()}:${timeNow.getSeconds()}`
await Promise.all(TargetResult[i].map(async(akun) => {
if (!getFollowers.includes(akun.id) && akun.params.isPrivate === false) {
var ranText = Text[Math.floor(Math.random() * Text.length)];
const ngeDo = await CommentAndLike(doLogin.session, akun.id, ranText)
console.log(chalk`[{magenta ${timeNow}}] {bold.green [>]} @${akun.params.username} => ${ngeDo}`)
} else {
console.log(chalk`[{magenta ${timeNow}}] {bold.yellow [SKIPPED]}${akun.params.username} => PRIVATE OR ALREADY FOLLOWED`)
}
}));
console.log(chalk`{yellow \n [#][>] Delay For ${Sleep} MiliSeconds [<][#] \n}`);
await delay(Sleep);
}
} catch (err) {
console.log(err);
}
}
co(function* () {
for (var i = 1; i <= 3; ++i) {
// delay between 2 and 3
if (i === 3) {
yield delay(100)
}
yield limiter().then(function (actual) {
assert.deepEqual(actual, { total: i, acknowledged: 1, remaining: LIMIT - i });
});
}
// the current capacity should be 3
assert.deepEqual(yield limiter.get(), { total: 3, remaining: LIMIT - 3, retryAfterMS: 0 });
yield limiter().then(function (actual) {
assert.deepEqual(actual, { total: 4, acknowledged: 1, remaining: LIMIT - 4 });
});
// the current capacity should be 4
assert.deepEqual(yield limiter.get(), { total: 4, remaining: LIMIT - 4, retryAfterMS: 0 });
for (var i = 5; i <= LIMIT; ++i) {
yield limiter().then(function (actual) {
assert.deepEqual(actual, { total: i, acknowledged: 1, remaining: LIMIT - i });
});
}
yield limiter.get().then(function (actual) {
assert.deepEqual(actual.total, LIMIT);
assert.deepEqual(actual.remaining, 0);
assert.deepEqual(actual.retryAfterMS > 800, true);
});
done();
}).catch(done);
co(function* () {
for (var i = 1; i <= LIMIT; ++i) {
yield limiter().then(function (actual) {
assert.deepEqual(actual, { total: i, acknowledged: 1, remaining: LIMIT - i });
});
}
// the current capacity should be reached
yield expectAmount(KEY, LIMIT);
// wait enough time for the next operations
yield delay(1000);
// fill up the bucket
for (var i = 1; i <= LIMIT; ++i) {
yield limiter().then(function (actual) {
assert.deepEqual(actual, { total: i, acknowledged: 1, remaining: LIMIT - i });
});
}
// the current capacity should be reached
yield expectAmount(KEY, LIMIT);
done();
}).catch(done);
const signin = async (user, opts) => {
const { browser } = opts;
const page = await browser.newPage();
await page.goto('https://login.live.com/');
await page.waitFor('input[type=email]', { visible: true });
await page.type('input[type=email]', user.email);
await page.click('input[type=submit]');
await page.waitFor('input[type=password]', { visible: true });
await page.type('input[type=password]', user.password);
await page.waitFor('input[type=checkbox]', { visible: true });
await page.click('input[type=checkbox]');
await Promise.all([
page.waitForNavigation(),
page.click('input[type=submit]')
]);
await page.waitFor('.c-action-menu');
await delay(500);
console.log('click drop down');
await page.click('.c-action-menu > .c-action-trigger');
await page.waitFor('.mee-icon-Mail', { timeout: 500 });
await page.click('.mee-icon-Mail');
// should now be at
// https://account.microsoft.com/?lang=en-US&refd=account.live.com&refp=landing
// await page.close()
};
ava(function (a) {
a.plan(3);
a.throws(delay.reject(10, new Error('foo')), 'foo');
a.notThrows(delay(10), 'foo');
setTimeout(function () {
a.throws(Promise.reject(new Error('foo')), 'foo');
}, 5);
}).run().then(function (result) {
it('should set update to a maximum of stale / 2', async () => {
fs.writeFileSync(`${tmpDir}/foo`, '');
expect.assertions(2);
await lockfile.lock(`${tmpDir}/foo`, { update: 6000, stale: 5000 });
const mtime = fs.statSync(`${tmpDir}/foo.lock`).mtime.getTime();
await pDelay(2000);
expect(mtime).toBe(fs.statSync(`${tmpDir}/foo.lock`).mtime.getTime());
await pDelay(1000);
expect(fs.statSync(`${tmpDir}/foo.lock`).mtime.getTime()).toBeGreaterThan(mtime);
}, 10000);
it('should set stale to a minimum of 2000 (falsy)', async () => {
fs.writeFileSync(`${tmpDir}/foo`, '');
fs.mkdirSync(`${tmpDir}/foo.lock`);
expect.assertions(1);
await pDelay(200);
try {
await lockfile.lock(`${tmpDir}/foo`, { stale: false });
} catch (err) {
expect(err.code).toBe('ELOCKED');
}
await pDelay(2000);
await lockfile.lock(`${tmpDir}/foo`, { stale: false });
});
test('cache', async t => {
const m = alfy();
t.deepEqual(await m.fetch(`${URL}/cache`, {maxAge: 5000}), {hello: 'world'});
t.deepEqual(await m.fetch(`${URL}/cache`, {maxAge: 5000}), {hello: 'world'});
await delay(5000);
t.deepEqual(await m.fetch(`${URL}/cache`, {maxAge: 5000}), {hello: 'world!'});
});
/**
* Runs the registered services.
*
* @public
* @function
*/
run() {
const areCredentialsPublished = this._publishCredentials();
if (areCredentialsPublished === false) {
delay(1000).then(() => {
this.run();
});
return;
}
this.server.listen(this.configuration.server.port);
}
const Excute = async function(User, TargetUsername, Sleep, mysyntx){
try {
console.log(chalk`{yellow \n [?] Try to Login . . .}`)
const doLogin = await Login(User);
console.log(chalk`{green [!] Login Succsess, }{yellow [?] Try To Get ID & Followers Target . . .}`)
const getTarget = await Target(TargetUsername);
console.log(chalk`{green [!] ${TargetUsername}: [${getTarget.id}] | Followers: [${getTarget.followers}]}`)
const getFollowers = await Followers(doLogin.session, doLogin.account.id)
console.log(chalk`{cyan [?] Try to Follow, Comment, and Like Followers Target . . . \n}`)
const Targetfeed = new Client.Feed.AccountFollowers(doLogin.session, getTarget.id);
var TargetCursor;
do {
if (TargetCursor) Targetfeed.setCursor(TargetCursor);
var TargetResult = await Targetfeed.get();
TargetResult = _.chunk(TargetResult, mysyntx);
for (let i = 0; i < TargetResult.length; i++) {
var timeNow = new Date();
timeNow = `${timeNow.getHours()}:${timeNow.getMinutes()}:${timeNow.getSeconds()}`
await Promise.all(TargetResult[i].map(async(akun) => {
if (!getFollowers.includes(akun.id) && akun.params.isPrivate === false) {
var Text = fs.readFileSync('komen.txt', 'utf8').split('|');
var ranText = Text[Math.floor(Math.random() * Text.length)];
const ngeDo = await CommentAndLike(doLogin.session, akun.id, ranText)
console.log(chalk`[{magenta ${timeNow}}] {bold.green [>]}${akun.params.username} => ${ngeDo}`)
} else {
console.log(chalk`[{magenta ${timeNow}}] {bold.yellow [SKIP]}${akun.params.username} => PRIVATE OR ALREADY FOLLOWED`)
}
}));
var ranSleep = Sleep[Math.floor(Math.random() * Sleep.length)];
console.log(chalk`{yellow \n [#][>] Delay For ${ranSleep} MiliSeconds [<][#] \n}`);
await delay(ranSleep);
}
TargetCursor = await Targetfeed.getCursor();
var ranSleep = Sleep[Math.floor(Math.random() * Sleep.length)];
console.log(chalk`{yellow \n [#][>] Delay For ${ranSleep} MiliSeconds [<][#] \n}`);
await delay(ranSleep);
} while(Targetfeed.isMoreAvailable());
} catch (err) {
console.log(err);
}
}
test(async t => {
const elCheck = m('#unicorn');
delay(500).then(() => {
const el = document.createElement('p');
el.id = 'unicorn';
document.body.appendChild(el);
});
const el = await elCheck;
t.is(el.id, 'unicorn');
});