function generateGenericDevice (options) {
options = options || {}
const templateName = options.templateName
const idx = options.idx
const orgIdx = options.orgIdx
const organization = options.organization || {}
const namePostfix = _.isNumber(idx) ? idx + 1 : ''
const name = options.name || `${(NAMES[templateName] || '').replace(/\s/g, '-')}-${namePostfix}`
const serialNumberPostfix = _.isNumber(orgIdx) && _.isNumber(idx) ? _.padStart(DEVICES_PER_ORGANIZATION[templateName] * orgIdx + idx + 1, 6, '0') : ''
const serialNumber = options.serialNumber || `${(NAMES[templateName] || '').replace(/\s/g, '-')}-${serialNumberPostfix}`
const deviceTemplateId = options.deviceTemplateId
const location = getLocation()
return {
name,
serialNumber,
deviceTemplateId,
deviceTemplate: NAMES[templateName],
organization: organization.name,
organizationId: organization.id,
color: faker.commerce.color(),
productionRun: 'DEC2016',
hardwareVersion: faker.system.semver(),
firmwareVersion: faker.system.semver(),
longitude: location[0],
latitude: location[1]
}
}
function dummyNote (override = {}) {
var data = Math.random() > 0.5
? {
type: 'MARKDOWN_NOTE',
content: faker.lorem.lines()
}
: {
type: 'SNIPPET_NOTE',
description: faker.lorem.lines(),
snippets: [{
name: faker.system.fileName(),
mode: 'text',
content: faker.lorem.lines()
}]
}
data.title = data.type === 'MARKDOWN_NOTE'
? data.content.split('\n').shift()
: data.description.split('\n').shift()
data.createdAt = faker.date.past()
data.updatedAt = faker.date.recent()
data.isStarred = false
data.tags = faker.lorem.words().split(' ')
if (override.key == null) data.key = keygen()
if (override.folder == null) data.folder = keygen()
Object.assign(data, override)
return data
}
app.get('/api/fake/system', function(req, res) {
res.json([
{
fileName: faker.system.fileName(),
commonFileName: faker.system.commonFileName(),
mimeType: faker.system.mimeType(),
commonFileType: faker.system.commonFileType(),
commonFileExt: faker.system.commonFileExt(),
fileType: faker.system.fileType(),
fileExt: faker.system.fileExt(),
directoryPath: faker.system.directoryPath(),
filePath: faker.system.filePath(),
semver: faker.system.semver()
}
])
});
const restaurantGenerator = () => {
const restaurantData = [];
for (let i = 0; i < 100; i += 1) {
const data = {};
const res_id = i + 1;
data.res_id = res_id;
const name = faker.system.fileName();
data.name = name;
const max_guest = faker.random.number({ min: 50, max: 200 });
data.max_guest = max_guest;
const amopen = faker.random.number({ min: 7, max: 11 });
const amclose = faker.random.number({ min: 12, max: 15 });
const pmopen = faker.random.number({ min: 15, max: 18 });
const pmclose = faker.random.number({ min: 20, max: 23 });
const hours = {
morning: { opentime: amopen, closetime: amclose, },
afternoon: { opentime: pmopen, closetime: pmclose, },
};
data.hours = hours;
const reservations = reservationGenerator();
data.reservations = reservations;
restaurantData.push(data);
}
return restaurantData;
};
beforeEach(function () {
Factory.define('recommendedProduct', recommendedProducts, {
variationId: faker.random.number(),
productName: faker.random.words(),
variationName: faker.random.words(),
productImage: faker.system.commonFileName(),
});
_.times(3, () => {
fiber(() => {
Factory.create('recommendedProduct');
}).run();
});
});
function newPath() {
if (knownPaths.length > 0 && faker.random.number(4) === 0) {
return similarPath()
}
let p = faker.system.fileName()
if (faker.random.number(4) === 0) {
p = faker.random.arrayElement(specialChars) + p
}
if (knownPaths.length > 0 && faker.random.number(3) > 0) {
p = faker.random.arrayElement(knownPaths) + '/' + p
}
knownPaths.push(p)
return p
}
async function generateCharacters(max = 6) {
const iterator = range(max - 1)
const characters = []
while (!iterator.next().done) {
characters.push({
name: name.findName(),
// TODO: replace it with system.filePath
// when this one will be added to faker.js
pic: system.fileName()
})
}
return await Character.createMany(characters)
}
function writeLine() {
var httpLine = faker.internet.ip();
httpLine += ' - - [';
httpLine += strftime("%d/%b/%Y:%H:%M:%S %z");
httpLine += '] \"GET ';
httpLine += '/' + faker.system.commonFileName(faker.random.arrayElement(fileExts));
httpLine += ' HTTP/1.1\" ';
httpLine += faker.random.arrayElement(respCodes) + " ";
httpLine += faker.random.number(8192) + 128;
httpLine += ' \"-\" \"';
httpLine += faker.internet.userAgent() + '\"';
console.log(httpLine);
// add a random factor to the interval
setTimeout(writeLine, (Math.random() + 1) * 1000 / speed);
}
test.serial('Delete a folder', (t) => {
const storageKey = t.context.storage.cache.key
const folderKey = t.context.storage.json.folders[0].key
let noteKey
const input1 = {
type: 'SNIPPET_NOTE',
description: faker.lorem.lines(),
snippets: [{
name: faker.system.fileName(),
mode: 'text',
content: faker.lorem.lines()
}],
tags: faker.lorem.words().split(' '),
folder: folderKey
}
input1.title = input1.description.split('\n').shift()
return Promise.resolve()
.then(function prepare () {
return createNote(storageKey, input1)
.then(function createAttachmentFolder (data) {
fs.mkdirSync(path.join(storagePath, attachmentManagement.DESTINATION_FOLDER))
fs.mkdirSync(path.join(storagePath, attachmentManagement.DESTINATION_FOLDER, data.key))
noteKey = data.key
return data
})
})
.then(function doTest () {
return deleteFolder(storageKey, folderKey)
})
.then(function assert (data) {
t.true(_.find(data.storage.folders, {key: folderKey}) == null)
const jsonData = CSON.readFileSync(path.join(data.storage.path, 'boostnote.json'))
t.true(_.find(jsonData.folders, {key: folderKey}) == null)
const notePaths = sander.readdirSync(data.storage.path, 'notes')
t.is(notePaths.length, t.context.storage.notes.filter((note) => note.folder !== folderKey).length)
const attachmentFolderPath = path.join(storagePath, attachmentManagement.DESTINATION_FOLDER, noteKey)
t.false(fs.existsSync(attachmentFolderPath))
})
})
before(() => {
path = faker.system.fileName()
stats = new fs.Stats()
})
function mvToOutside() {
const src = knownPath()
const dst = '../outside/' + faker.system.fileName()
outsidePaths.push(dst)
return { op: 'mv', from: src, to: dst }
}
ip: '40.40.40.40',
os: 'unknown',
wsPort: null,
httpPort: null,
state: null,
nonce: '',
version: '',
},
init({ broadhash, nonce, state }) {
this.dappid = null;
this.height = parseInt(_.sample([50, 70, 90, 110]));
this.ip = faker.internet.ip();
this.os = faker.lorem.slug();
this.wsPort = `5${faker.random.number({ max: 999, min: 100 })}`;
this.httpPort = `4${faker.random.number({ max: 999, min: 100 })}`;
this.version = faker.system.semver();
this.broadhash =
broadhash ||
randomstring.generate({
charset: 'hex',
length: 64,
capitalization: 'lowercase',
});
this.state = state || 2; // Connected Peer
this.nonce = nonce || randomstring.generate(16);
},
});
const DBPeer = stampit(Peer, {
props: {
test.serial('Create a note', (t) => {
const storageKey = t.context.storage.cache.key
const folderKey = t.context.storage.json.folders[0].key
const input1 = {
type: 'SNIPPET_NOTE',
description: faker.lorem.lines(),
snippets: [{
name: faker.system.fileName(),
mode: 'text',
content: faker.lorem.lines()
}],
tags: faker.lorem.words().split(' '),
folder: folderKey
}
input1.title = input1.description.split('\n').shift()
const input2 = {
type: 'MARKDOWN_NOTE',
content: faker.lorem.lines(),
tags: faker.lorem.words().split(' '),
folder: folderKey
}
input2.title = input2.content.split('\n').shift()
return Promise.resolve()
.then(function doTest () {
return Promise.all([
createNote(storageKey, input1),
createNote(storageKey, input2)
])
})
.then(function assert (data) {
let data1 = data[0]
let data2 = data[1]
t.is(storageKey, data1.storage)
let jsonData1 = CSON.readFileSync(path.join(storagePath, 'notes', data1.key + '.cson'))
t.is(input1.title, data1.title)
t.is(input1.title, jsonData1.title)
t.is(input1.description, data1.description)
t.is(input1.description, jsonData1.description)
t.is(input1.tags.length, data1.tags.length)
t.is(input1.tags.length, jsonData1.tags.length)
t.is(input1.snippets.length, data1.snippets.length)
t.is(input1.snippets.length, jsonData1.snippets.length)
t.is(input1.snippets[0].content, data1.snippets[0].content)
t.is(input1.snippets[0].content, jsonData1.snippets[0].content)
t.is(input1.snippets[0].name, data1.snippets[0].name)
t.is(input1.snippets[0].name, jsonData1.snippets[0].name)
t.is(storageKey, data2.storage)
let jsonData2 = CSON.readFileSync(path.join(storagePath, 'notes', data2.key + '.cson'))
t.is(input2.title, data2.title)
t.is(input2.title, jsonData2.title)
t.is(input2.content, data2.content)
t.is(input2.content, jsonData2.content)
t.is(input2.tags.length, data2.tags.length)
t.is(input2.tags.length, jsonData2.tags.length)
})
})
app.get('/api/fake', function(req, res) {
res.json({
"address": {
zipCode: faker.address.zipCode(),
city: faker.address.city(),
cityPrefix: faker.address.cityPrefix(),
citySuffix: faker.address.citySuffix(),
streetName: faker.address.streetName(),
streetAddress: faker.address.streetAddress(),
streetSuffix: faker.address.streetSuffix(),
streetPrefix: faker.address.streetPrefix(),
secondaryAddress: faker.address.secondaryAddress(),
county: faker.address.county(),
country: faker.address.country(),
countryCode: faker.address.countryCode(),
state: faker.address.state(),
stateAbbr: faker.address.stateAbbr(),
latitude: faker.address.latitude(),
longitude: faker.address.longitude()
},
"commerce": {
color: faker.commerce.color(),
department: faker.commerce.department(),
productName: faker.commerce.productName(),
price: faker.commerce.price(),
productAdjective: faker.commerce.productAdjective(),
productMaterial: faker.commerce.productMaterial(),
product: faker.commerce.product()
},
"company": {
suffixes: faker.company.suffixes(),
companyName: faker.company.companyName(),
companySuffix: faker.company.companySuffix(),
catchPhrase: faker.company.catchPhrase(),
bs: faker.company.bs(),
catchPhraseAdjective: faker.company.catchPhraseAdjective(),
catchPhraseDescriptor: faker.company.catchPhraseDescriptor(),
catchPhraseNoun: faker.company.catchPhraseNoun(),
bsAdjective: faker.company.bsAdjective(),
bsBuzz: faker.company.bsBuzz(),
bsNoun: faker.company.bsNoun()
},
"date": {
past: faker.date.past(),
future: faker.date.future(),
between: faker.date.between(),
recent: faker.date.recent(),
month: faker.date.month(),
weekday: faker.date.weekday()
},
"finance": {
account: faker.finance.account(),
accountName: faker.finance.accountName(),
mask: faker.finance.mask(),
amount: faker.finance.amount(),
transactionType: faker.finance.transactionType(),
currencyCode: faker.finance.currencyCode(),
currencyName: faker.finance.currencyName(),
currencySymbol: faker.finance.currencySymbol(),
bitcoinAddress: faker.finance.bitcoinAddress()
},
"hacker": {
abbreviation: faker.hacker.abbreviation(),
adjective: faker.hacker.adjective(),
noun: faker.hacker.noun(),
verb: faker.hacker.verb(),
ingverb: faker.hacker.ingverb(),
phrase: faker.hacker.phrase()
},
"helpers": {
randomize: faker.helpers.randomize(),
slugify: faker.helpers.slugify(),
replaceSymbolWithNumber: faker.helpers.replaceSymbolWithNumber(),
replaceSymbols: faker.helpers.replaceSymbols(),
shuffle: faker.helpers.shuffle(),
mustache: faker.helpers.mustache(),
createCard: faker.helpers.createCard(),
contextualCard: faker.helpers.contextualCard(),
userCard: faker.helpers.userCard(),
createTransaction: faker.helpers.createTransaction()
},
"image": {
image: faker.image.image(),
avatar: faker.image.avatar(),
imageUrl: faker.image.imageUrl(),
abstract: faker.image.abstract(),
animals: faker.image.animals(),
business: faker.image.business(),
cats: faker.image.cats(),
city: faker.image.city(),
food: faker.image.food(),
nightlife: faker.image.nightlife(),
fashion: faker.image.fashion(),
people: faker.image.people(),
nature: faker.image.nature(),
sports: faker.image.sports(),
technics: faker.image.technics(),
transport: faker.image.transport()
},
"internet": {
avatar: faker.internet.avatar(),
email: faker.internet.email(),
exampleEmail: faker.internet.exampleEmail(),
userName: faker.internet.userName(),
protocol: faker.internet.protocol(),
url: faker.internet.url(),
domainName: faker.internet.domainName(),
domainSuffix: faker.internet.domainSuffix(),
domainWord: faker.internet.domainWord(),
ip: faker.internet.ip(),
userAgent: faker.internet.userAgent(),
color: faker.internet.color(),
mac: faker.internet.mac(),
password: faker.internet.password()
},
"lorem": {
word: faker.lorem.word(),
words: faker.lorem.words(),
sentence: faker.lorem.sentence(),
sentences: faker.lorem.sentences(),
paragraph: faker.lorem.paragraph(),
paragraphs: faker.lorem.paragraphs(),
text: faker.lorem.text(),
lines: faker.lorem.lines()
},
"name": {
firstName: faker.name.firstName(),
lastName: faker.name.lastName(),
findName: faker.name.findName(),
jobTitle: faker.name.jobTitle(),
prefix: faker.name.prefix(),
suffix: faker.name.suffix(),
title: faker.name.title(),
jobDescriptor: faker.name.jobDescriptor(),
jobArea: faker.name.jobArea(),
jobType: faker.name.jobType()
},
"phone": {
phoneNumber: faker.phone.phoneNumber(),
phoneNumberFormat: faker.phone.phoneNumberFormat(),
phoneFormats: faker.phone.phoneFormats()
},
"random": {
number: faker.random.number(),
arrayElement: faker.random.arrayElement(),
objectElement: faker.random.objectElement(),
uuid: faker.random.uuid(),
boolean: faker.random.boolean(),
word: faker.random.word(),
words: faker.random.words(),
image: faker.random.image(),
locale: faker.random.locale(),
alphaNumeric: faker.random.alphaNumeric()
},
"system": {
fileName: faker.system.fileName(),
commonFileName: faker.system.commonFileName(),
mimeType: faker.system.mimeType(),
commonFileType: faker.system.commonFileType(),
commonFileExt: faker.system.commonFileExt(),
fileType: faker.system.fileType(),
fileExt: faker.system.fileExt(),
directoryPath: faker.system.directoryPath(),
filePath: faker.system.filePath(),
semver: faker.system.semver()
}
})
});