Created
September 9, 2018 16:13
-
-
Save ghenzler/f09bba09054ea4be8af6861b33ac6891 to your computer and use it in GitHub Desktop.
iteratively creates child nodes under same parent and displays them with chrome headless in CRXDE and Composium
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
//------------------------------------- | |
// *** Max Child Nodes | |
//. UI Test (CRXDE and Composum) | |
//------------------------------------- | |
// Breaklet Config | |
//------------------------------------- | |
def breakForDurationInSec = 120 | |
def basePath = "/content/nodetest" | |
def nodesToCreatePerIteration = 1000 | |
def primaryType = "nt:unstructured" // "oak:Unstructured" => not orderable, "nt:unstructured" => orderable | |
def sessionUser = 'admin' | |
def sessionPassword = 'admin' | |
//------------------------------------- | |
// Breaklet | |
//------------------------------------- | |
def getNodeName = { iteration, nodeNum -> | |
"node" + StringUtils.leftPad(String.valueOf(iteration), 14, '0') + '-' + StringUtils.leftPad(String.valueOf(nodeNum), 4, '0') | |
} | |
new Breaklet(this, breakForDurationInSec, sessionUser, sessionPassword).run { breaklet, currentIt, itSession -> | |
// create nodes | |
def firstNodeName = null | |
def lastNodeName | |
for(int nodeNum=1; nodeNum<=nodesToCreatePerIteration; nodeNum++) { | |
lastNodeName = getNodeName(currentIt, nodeNum) | |
if(!firstNodeName) { | |
firstNodeName = lastNodeName | |
} | |
def path = basePath + "/" + lastNodeName | |
def node = JcrUtils.getOrCreateByPath(path, true, primaryType, primaryType, itSession, false) | |
node.setProperty("randomNumber", ThreadLocalRandom.current().nextInt(0, 100)) | |
if(nodeNum % 10 == 7) { // set property on 10% of the nodes | |
node.setProperty("sling:resourceType", "special") | |
} | |
} | |
breaklet.logOpFinished("Create "+nodesToCreatePerIteration+" nodes", "(up to "+(currentIt*nodesToCreatePerIteration)+" nodes in total)") | |
itSession.save() | |
breaklet.logOpFinished("Save "+nodesToCreatePerIteration+" nodes") | |
// re-order nodes | |
if(currentIt > 1) { | |
def reorderParent = itSession.getNode(basePath) | |
for(int nodeNum=1; nodeNum<=nodesToCreatePerIteration; nodeNum++) { | |
reorderParent.orderBefore(getNodeName(currentIt, nodeNum), getNodeName(currentIt-1, nodeNum)) | |
} | |
breaklet.logOpFinished("Reorder "+nodesToCreatePerIteration+" nodes") | |
itSession.save() | |
breaklet.logOpFinished("Save "+nodesToCreatePerIteration+" reordered nodes") | |
} | |
// count nodes | |
def parentNode = itSession.getNode(basePath) | |
int count = 0 | |
parentNode.getNodes().each { child -> | |
count++ | |
} | |
breaklet.logOpFinished("Count nodes underneath parent", "(up to "+count+")") | |
// query nodes | |
QueryManager queryManager = itSession.getWorkspace().getQueryManager(); | |
Query query = queryManager.createQuery("/jcr:root/content/nodetest//*[sling:resourceType='special']", Query.XPATH); | |
QueryResult result = query.execute(); | |
NodeIterator nodes = result.getNodes(); | |
int hitCount = 0 | |
while (nodes.hasNext() && nodes.next() != null) { | |
hitCount++ | |
} | |
breaklet.logOpFinished("Count nodes with query", "for resource type 'special' (found "+ hitCount + ")") | |
breaklet.runInBrowser(""" | |
console.log("Testing with CRXDE") | |
await page.goto(baseUrl+'/crx/de/index.jsp'); | |
let crxDeNodeContent = await waitForCrxdeNodeWithName(page, 'content'); | |
await clickOnIconOfCrxdeNode(page, crxDeNodeContent) | |
let crxDeNodeNodeTest = await waitForCrxdeNodeWithName(page, 'nodetest'); | |
page.on('response', response => { | |
if (response.url().indexOf("/crx/server/crx.default/jcr%3aroot${basePath}.1.json")!==-1) { | |
let delta = new Date().getTime()-startMillis | |
resultProps['crxdeAjaxRequestForNodesTiming'] = delta | |
console.log("Ajax request for ${basePath} done after "+delta); | |
} | |
}); | |
await clickOnIconOfCrxdeNode(page, crxDeNodeNodeTest) | |
let crxDeNodeFirstCreatedNode = await waitForCrxdeNodeWithName(page, '$lastNodeName'); | |
await clickOnIconOfCrxdeNode(page, crxDeNodeFirstCreatedNode) | |
let crxdeLoad = new Date().getTime()-startMillis | |
resultProps['crxdeLoad'] = crxdeLoad | |
await createScreenshot(page, 'CRXDE') | |
await sleep(50) | |
console.log("Testing with Composum") | |
startMillis = new Date().getTime() | |
await page.goto(baseUrl+'/bin/browser.html/content'); | |
page.on('response', response => { | |
if (response.url().indexOf("/bin/cpm/nodes/node.tree.json${basePath}")!==-1) { | |
let delta = new Date().getTime()-startMillis | |
resultProps['composumAjaxRequestForNodesTiming'] = delta | |
console.log("Ajax request for ${basePath} done after "+delta); | |
} | |
}); | |
let nodeElNodeTestXPath = "//*[@id='browser-tree']//a[contains(text(),'nodetest')]" | |
let nodeElNodeTest = await waitForXPath(page, nodeElNodeTestXPath) | |
nodeElNodeTest.click() | |
let nodeElXPath = "//*[@id='browser-tree']//a[contains(text(),'$lastNodeName')]" | |
let nodeEl = await waitForXPath(page, nodeElXPath) | |
nodeEl.click() | |
let composumLoad = new Date().getTime()-startMillis | |
resultProps['composumLoad'] = composumLoad | |
await createScreenshot(page, 'composum') | |
""") | |
breaklet.logOpFinished("Request nodes from server in Composum", "", breaklet.browser.resultProps['composumAjaxRequestForNodesTiming']) | |
breaklet.logOpFinished("Show all nodes in Composum", "(all "+ count + " incl "+lastNodeName+")", breaklet.browser.resultProps['composumLoad']) | |
breaklet.logOpFinished("Request nodes from server in CRXDE", "", breaklet.browser.resultProps['crxdeAjaxRequestForNodesTiming']) | |
breaklet.logOpFinished("Show all nodes in CRXDE", "(all "+ count + " incl "+lastNodeName+")", breaklet.browser.resultProps['crxdeLoad']) | |
} | |
session.removeItem(basePath) | |
session.save() | |
// DO NOT CHANGE BEYOND THIS POINT - master is https://gist.github.com/ghenzler/58ce57794ba9b5a60f2a2e60160be747 here | |
// -------------------------------------------------------------------- | |
// Breaklet Base Utilities (to be copied at bottom of other breaklets) | |
// -------------------------------------------------------------------- | |
import org.apache.jackrabbit.commons.JcrUtils | |
import org.apache.commons.lang3.StringUtils | |
import java.util.concurrent.ThreadLocalRandom | |
import javax.jcr.query.* | |
import org.apache.sling.jcr.api.* | |
import org.apache.sling.api.resource.observation.* | |
import java.util.Properties | |
import java.io.ByteArrayInputStream | |
import java.nio.charset.StandardCharsets | |
import org.osgi.service.event.EventConstants | |
import org.osgi.service.event.EventHandler | |
import org.osgi.service.event.Event | |
import org.apache.commons.io.IOUtils | |
import org.apache.sling.hc.util.FormattingResultLog | |
class BreakletBrokeException extends RuntimeException { | |
String opName | |
String timeSpent | |
BreakletBrokeException(opName, timeSpent) { | |
this.opName = opName | |
this.timeSpent = timeSpent | |
} | |
} | |
class BreakletPanicException extends RuntimeException { } | |
class Breaklet { | |
int iterations | |
int breakForDurationInSec | |
String user | |
String password | |
long lastTimestamp = System.currentTimeMillis() | |
def script | |
long currentIteration | |
String currentItLogMarker | |
Map<String,List> timings = new LinkedHashMap<String,List>() | |
Browser browser | |
def resourceChangeListener = null | |
def resourceChangeListenerReg = null | |
def resourceChangeListenerPath = null | |
def resourceChangeEventHandler = null | |
def resourceChangeEventHandlerReg = null | |
def resourceChangeEventHandlerPath = null | |
Breaklet(def script, int breakForDurationInSec, String user=null, String password=null, int iterations=Integer.MAX_VALUE) { | |
this.script = script | |
this.breakForDurationInSec = breakForDurationInSec | |
this.user = user | |
this.password = password | |
this.iterations = iterations | |
this.browser = new Browser(script, breakForDurationInSec, user, password) | |
} | |
def logOpFinished(String opName, String opDescription="", def timeSpentMillis=null, def neverBreak=false) { | |
script.logMsg(StringUtils.leftPad(currentItLogMarker, 7)+" " + StringUtils.rightPad(getTimeSpent(opName, timeSpentMillis as Long, neverBreak) + ":", 8) + " "+opName + " "+opDescription) | |
currentItLogMarker = "" | |
} | |
def getTimeSpent(String opName, Long timeSpentMillis=null, def neverBreak=false) { | |
long delta = timeSpentMillis ?: System.currentTimeMillis()-lastTimestamp | |
def timingSeriesForOp = timings.get(opName) | |
if(timingSeriesForOp==null) { timings.put(opName, (timingSeriesForOp = new ArrayList<Long>())) } | |
while(timingSeriesForOp.size() < currentIteration-1) { timingSeriesForOp.add(timingSeriesForOp.size(), '') } | |
timingSeriesForOp.add((int)currentIteration-1, delta) | |
String timeSpent = FormattingResultLog.msHumanReadable(delta) | |
if((delta/1000) > breakForDurationInSec && !neverBreak) { | |
throw new BreakletBrokeException(opName, timeSpent) | |
} | |
lastTimestamp = System.currentTimeMillis() | |
return timeSpent | |
} | |
def run(toRun) { | |
File currentWorkingDir = new File(System.getProperty('user.dir')) | |
File panicFile = new File(currentWorkingDir, 'panic') | |
try { | |
(1..iterations).each { itNo -> | |
currentItLogMarker = itNo+":" | |
def sessionForIteration = null | |
try { | |
if(StringUtils.isNotBlank(user)) { | |
sessionForIteration = getSessionFor(user, password) | |
} | |
currentIteration = itNo | |
def sessionForIt = sessionForIteration ?: script.session | |
toRun(this, currentIteration, sessionForIt) | |
if(panicFile.exists()) { | |
panicFile.renameTo(new File(currentWorkingDir, 'no-panic')) | |
throw new BreakletPanicException() | |
} | |
} finally { | |
if(sessionForIteration!=null && sessionForIteration.isLive()) { | |
sessionForIteration.logout() | |
} | |
} | |
} | |
script.logMsg("\n\nBreaklet survived - "+iterations+" iterations finished without exceeding the threshold\n") | |
} catch(BreakletBrokeException e) { | |
script.logMsg("\n\nBreaklet broke at iteration "+currentIteration+": Operation '"+e.opName+"' "+e.timeSpent + " >= "+breakForDurationInSec + "sec\n") | |
} catch(BreakletPanicException e) { | |
script.logMsg("\nBreaklet broke due to panic after iteration "+currentIteration+"\n") | |
} catch(Exception e) { | |
script.logMsg("\n\nBreaklet broke at iteration "+currentIteration+" with unexpected exception: "+e) | |
script.log.info("Exception:"+e, e) | |
} finally { | |
String result = "" | |
timings.keySet().each { key -> | |
result += ""+key+","+ StringUtils.join(timings.get(key),',') + "\n" | |
} | |
new File(currentWorkingDir, 'breaklet-result-'+new Date().getTime()+'.csv').text = result | |
if(resourceChangeListenerReg) { | |
resourceChangeListenerReg.unregister() | |
} | |
if(resourceChangeEventHandlerReg) { | |
resourceChangeEventHandlerReg.unregister() | |
} | |
} | |
} | |
def runInBrowser(String puppeteerScript) { | |
return browser.run(puppeteerScript) | |
} | |
def getSessionFor(sessionUser, sessionPassword) { | |
def repository = script.session.getRepository() | |
def session = repository.login(new SimpleCredentials(sessionUser, sessionPassword.toCharArray())); | |
return session | |
} | |
def registerResourceChangeListener(paths) { | |
resourceChangeListenerPath = paths | |
resourceChangeListener = new ResourceChangeListener() { | |
int changesReceived = 0 | |
int callsReceived = 0 | |
def allChanges = [] | |
public void onChange(List<ResourceChange> changes) { | |
changesReceived += changes.size() | |
callsReceived++ | |
allChanges.addAll(changes) | |
} | |
public void reset() { | |
changesReceived = 0 | |
callsReceived = 0 | |
allChanges = [] | |
} | |
} | |
resourceChangeListenerReg = script.bundleContext.registerService("org.apache.sling.api.resource.observation.ResourceChangeListener", resourceChangeListener, new Hashtable([(ResourceChangeListener.PATHS): paths])) | |
return resourceChangeListener | |
} | |
def registerResourceChangeEventHandler(path) { | |
resourceChangeEventHandlerPath = path | |
resourceChangeEventHandler = new EventHandler() { | |
int eventsReceived = 0 | |
def allEvents = [] | |
public void handleEvent(final Event event) { | |
eventsReceived++ | |
allEvents.addAll(event) | |
} | |
public void reset() { | |
eventsReceived = 0 | |
allEvents = [] | |
} | |
} | |
resourceChangeEventHandlerReg = script.bundleContext.registerService("org.osgi.service.event.EventHandler", resourceChangeEventHandler, | |
new Hashtable([ | |
(EventConstants.EVENT_TOPIC): "org/apache/sling/api/resource/Resource/*", | |
(EventConstants.EVENT_FILTER): "("+SlingConstants.PROPERTY_PATH+"="+path+"*)", | |
])) | |
return resourceChangeEventHandler | |
} | |
def waitForResourceChangedEvents(long minimumExpectedChanges, long maxWaitInSec=300, String opName=null) { | |
boolean timeout = false | |
int waitCounter = 0 | |
while((resourceChangeListener && resourceChangeListener.changesReceived < minimumExpectedChanges) | |
|| (resourceChangeEventHandler && resourceChangeEventHandler.eventsReceived < minimumExpectedChanges) | |
) { | |
if((lastTimestamp + maxWaitInSec*1000) < System.currentTimeMillis()) { | |
timeout = true | |
break | |
} | |
Thread.sleep(50) | |
} | |
String resourceChangeListenerResult = resourceChangeListener ? " changesReceived="+resourceChangeListener.changesReceived+" (in "+resourceChangeListener.callsReceived +" calls) " : "" | |
String resourceChangeEventHandlerResult = resourceChangeEventHandler ? " eventsReceived="+resourceChangeEventHandler.eventsReceived : "" | |
opName = opName ?: "Wait for resource changed events ("+(resourceChangeListenerPath?:resourceChangeEventHandlerPath)+")" | |
logOpFinished(opName, (timeout?'Timed out after '+maxWaitInSec+'sec ':'') + resourceChangeListenerResult + resourceChangeEventHandlerResult) | |
resourceChangeListener?.reset() | |
resourceChangeEventHandler?.reset() | |
} | |
def performRequest(String requestPath, String reqUser=user, String reqPassword=password) { | |
def con = new URL(script.getBaseUrl()+requestPath).openConnection(); | |
String encoded = Base64.getEncoder().encodeToString((reqUser+":"+reqPassword).getBytes(StandardCharsets.UTF_8)); | |
con.setRequestProperty("Authorization", "Basic "+encoded); | |
def result = IOUtils.toString(con.getInputStream()); | |
return result | |
} | |
} | |
class Browser { | |
// config | |
def script | |
String user | |
String password | |
int breakForDurationInSec | |
// state | |
File browserDir | |
String testJsTemplate | |
Properties resultProps | |
Browser(def script, int breakForDurationInSec, String user, String password) { | |
this.script = script | |
this.breakForDurationInSec = breakForDurationInSec | |
this.user = user | |
this.password = password | |
} | |
def init() { | |
browserDir = new File(System.getProperty('user.dir')+'/puppeteer') | |
if(!browserDir.exists()) { | |
script.logMsg("init "+ browserDir) | |
browserDir.mkdir() | |
new File(browserDir, 'package.json').text = """ | |
{ | |
"name": "puppeteer-breaklet", | |
"version": "1.0.0", | |
"scripts": { | |
"test": "node test.js" | |
}, | |
"dependencies": { | |
"puppeteer": "1.7.0" | |
} | |
} | |
""".stripIndent() | |
def result = script.exec("npm install", browserDir) | |
script.logMsg("npm install result: "+ result) | |
} | |
testJsTemplate = ''' | |
const puppeteer = require('puppeteer'); | |
let baseUrl = process.argv[2] | |
let user = process.argv[3] | |
let password = process.argv[4] | |
let startTime = process.argv[5] | |
let defaultTimeout = 120*1000 | |
let screenshotCreated = false | |
let loginPage = "/libs/granite/core/content/login.html" | |
function sleep(ms) { | |
return new Promise(resolve => setTimeout(resolve, ms)); | |
} | |
function getCrxdeXPath(nodeName) { | |
return "//*[@id='repository']//a[span/text()='"+nodeName+"']" | |
} | |
async function waitForXPath(page, xpath) { | |
await page.waitForXPath(xpath, { timeout: defaultTimeout}) | |
let nodeElements = await page.$x(xpath) | |
return nodeElements[0] | |
} | |
async function waitForCrxdeNodeWithName(page, nodeName) { | |
let nodeElXPath = getCrxdeXPath(nodeName) | |
return await waitForXPath(page, nodeElXPath) | |
} | |
async function waitForAndClick(page, selector, retry=true) { | |
await page.waitForSelector(selector, { timeout: defaultTimeout, visible: true}) | |
if (await page.$(selector) === null) { | |
throw new Error("Could not find " + selector + " even after waiting for " + defaultTimeout); | |
} | |
try { | |
await page.click(selector) | |
} catch(err) { | |
if(retry) { | |
console.log("Error " +err+" while clicking on selector "+selector+", retrying...") | |
await sleep(200) | |
waitForAndClick(page, selector, false); | |
} else { | |
throw err | |
} | |
} | |
} | |
async function clickOnIconOfCrxdeNode(page, nodeHandle) { | |
await page.evaluate(node => node.previousSibling.previousSibling.click(), nodeHandle); | |
} | |
async function createScreenshot(page, name=null) { | |
if(page) { | |
await page.screenshot({path: 'run-'+startMillis+(name ? '-'+name : '')+'.png'}); | |
screenshotCreated = true | |
} | |
} | |
async function run() { | |
var resultProps = {}; | |
const browser = await puppeteer.launch({headless: true, dumpio: true, args: ['--window-size=1440,900', "--no-sandbox"]}); | |
let page = null | |
try { | |
//const context = await browser.createIncognitoBrowserContext(); | |
page = await browser.newPage(); // context or browser | |
await page.setViewport({width: 1440, height: 900}); | |
await page.goto(baseUrl + loginPage); | |
await page.$eval('#username', (el, pUsername) => el.value = pUsername, user); | |
await page.$eval('#password', (el, pPassword) => el.value = pPassword, password); | |
await sleep(500); | |
await page.$eval('#login', form => form.submit()); | |
await page.waitForNavigation({ waitUntil: 'networkidle0'}) | |
if(new RegExp('.*?'+loginPage+'.*').test(await page.url())) { | |
throw new Error("Could not login!"); | |
} else { | |
console.log("Logged in user "+user) | |
} | |
startMillis = new Date().getTime() | |
console.log("Starting user script at start milliseconds =", startMillis) | |
%SCRIPT% | |
} catch(err) { | |
console.log("Error during execution: ", err) | |
} finally { | |
if(!screenshotCreated) { | |
await createScreenshot(page) | |
} | |
browser.close(); | |
let delta = new Date().getTime()-startMillis | |
console.log("----------------") | |
for (let key in resultProps) { | |
console.log(key+"="+resultProps[key]) | |
} | |
console.log("browserDurationInMillis="+delta) | |
} | |
} | |
run(); | |
'''.stripIndent() | |
} | |
def run(String scriptToRun) { | |
init() | |
new File(browserDir, 'test.js').text = testJsTemplate.replace('%SCRIPT%', scriptToRun) | |
def baseUrl = script.getBaseUrl() | |
def startTime = System.currentTimeMillis() | |
def cmd = "npm test $baseUrl $user $password $startTime" | |
def scriptResult = script.exec(cmd, browserDir, breakForDurationInSec) | |
new File(browserDir, 'run-'+new Date().getTime()+".log").text = scriptResult | |
if(scriptResult.contains("Error during execution:")) { | |
throw new IllegalStateException("Browser execution failed") | |
} | |
def propsString = StringUtils.substringAfter(scriptResult, "----------------\n") | |
resultProps = new Properties() | |
resultProps.load(new ByteArrayInputStream(propsString.getBytes(StandardCharsets.UTF_8))) | |
long browserDurationInMillis = resultProps.containsKey('breakForDurationInSec') ? Long.parseLong(resultProps.getProperty('breakForDurationInSec')) : (System.currentTimeMillis()-startTime) | |
return browserDurationInMillis | |
} | |
} | |
def logMsg(String msg) { | |
log.info(msg) | |
println(msg) | |
} | |
def getBaseUrl() { | |
def aemPort = System.getProperty('sun.java.command').replaceFirst(".*?-p ([0-9]+) .*", "\$1") | |
return "http://localhost:"+aemPort | |
} | |
import org.apache.commons.exec.CommandLine | |
import org.apache.commons.exec.DefaultExecutor | |
import org.apache.commons.exec.PumpStreamHandler | |
import org.apache.commons.exec.ExecuteWatchdog | |
def exec(String command, File dir, int breakForDurationInSec=600) { | |
CommandLine cmdLine = CommandLine.parse(command); | |
DefaultExecutor executor = new DefaultExecutor(); | |
executor.setWorkingDirectory(dir) | |
ExecuteWatchdog watchdog = new ExecuteWatchdog(breakForDurationInSec * 1000); | |
executor.setWatchdog(watchdog); | |
ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); | |
PumpStreamHandler streamHandler = new PumpStreamHandler(outputStream); | |
executor.setStreamHandler(streamHandler); | |
executor.setExitValues([0,1,143] as int[]) | |
int exitValue = executor.execute(cmdLine); | |
String scriptOutput = outputStream.toString() | |
if(exitValue == 1) { | |
logMsg("Script '"+command+"' returned exit code 1, output:\n "+ scriptOutput) | |
} | |
return scriptOutput | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment