stack/loadtests/src/main/scala/org/apache/usergrid/scenarios/EntityCollectionScenarios.scala - usergrid - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.usergrid.scenarios

 import io.gatling.core.Predef._
 import io.gatling.core.feeder.RecordSeqFeederBuilder
 import io.gatling.http.Predef._
 import org.apache.usergrid.datagenerators.FeederGenerator
 import org.apache.usergrid.enums.{CsvFeedPatternType, EndConditionType, AuthType}
 import org.apache.usergrid.helpers.Extractors._
 import org.apache.usergrid.helpers.{Headers, Utils}
 import org.apache.usergrid.settings.Settings

 /**
  * Provides CRUD methods for custom entities
  *
  *
  *
  */
 object EntityCollectionScenarios {

   //The value for the cursor
   val SessionVarCursor: String = "cursor"
   val SessionVarUuid: String = "createUuid"

   def entityGetUrl(useCursor: Boolean): String = {
     val url = s"/${Settings.collection}?" +
       (if (useCursor) "cursor=${" + SessionVarCursor + "}&" else "") +
       (if (Settings.searchQuery != "") s"ql=${Settings.searchQuery}&" else "") +
       (if (Settings.searchLimit > 0) s"limit=${Settings.searchLimit}&" else "")

     // remove trailing & or ?
     url.dropRight(1)
   }

   def entityGetByNameUrl(entityName: String): String = {

     s"/${Settings.collection}/$entityName"
   }

   def randomEntityNameUrl(prefix: String = Settings.entityPrefix, numEntities: Int = Settings.numEntities, seed: Int = Settings.entitySeed): String = {

     Utils.randomEntityNameUrl(prefix, numEntities, seed, Settings.baseCollectionUrl)
   }

   def uuidFeeder(): RecordSeqFeederBuilder[String] = {
     if (Settings.csvFeedPattern == CsvFeedPatternType.Circular) {
       csv(Settings.feedUuidFilename).circular
     } else {
       csv(Settings.feedUuidFilename).random
     }
   }

   /*
    * Loop through entities using cursor
    */
   val getEntitiesWithoutCursor = exec(
     http("GET entities")
       .get(entityGetUrl(false))
       .headers(Headers.authToken)
       .check(status.is(200), maybeExtractCursor(SessionVarCursor))
   )

   val getEntitiesWithCursor = exec(
     http("GET entities")
       .get(entityGetUrl(true))
       .headers(Headers.authToken)
       .check(status.is(200), maybeExtractCursor(SessionVarCursor))
   )

   val getEntityPagesToEnd = scenario("Get all entities")
     .exec(injectTokenIntoSession())
     .exec(injectAuthType())
     .doIfOrElse(_ => Settings.endConditionType == EndConditionType.MinutesElapsed) {
       asLongAs(_ => Settings.continueMinutesTest, exitASAP = true) {
         exec(getEntitiesWithoutCursor)
           .asLongAs(stringParamExists(SessionVarCursor)) {
           exec(getEntitiesWithCursor)
         }
       }
     } {
       repeat(_ => Settings.endRequestCount.toInt) {
         exec(getEntitiesWithoutCursor)
           .asLongAs(stringParamExists(SessionVarCursor)) {
           exec(getEntitiesWithCursor)
         }
       }
     }
     //.exec(sessionFunction => { sessionFunction })

   /*
    * Get random entities by name
    */
   val getRandomEntityAnonymous = exec(
     http("GET entity by name (anonymous)")
       .get(randomEntityNameUrl())
       .headers(Headers.authAnonymous)
       .check(status.is(200))
   )

   val getRandomEntityWithToken = exec(
     http("GET entity by name (token)")
       .get(randomEntityNameUrl())
       .headers(Headers.authToken)
       .check(status.is(200))
   )

   val getRandomEntitiesByName = scenario("Get entities by name randomly")
     .exec(injectTokenIntoSession())
     .exec(injectAuthType())
     .doIfOrElse(_ => Settings.endConditionType == EndConditionType.MinutesElapsed) {
     asLongAs(_ => Settings.continueMinutesTest) {
       tryMax(Settings.retryCount) {
         doIfOrElse(_ => Settings.authType == AuthType.Anonymous) {
           exec(getRandomEntityAnonymous)
         } {
           exec(getRandomEntityWithToken)
         }
       }
     }
   } {
     repeat(_ => Settings.endRequestCount.toInt) {
       tryMax(Settings.retryCount) {
         doIfOrElse(_ => Settings.authType == AuthType.Anonymous) {
           exec(getRandomEntityAnonymous)
         } {
           exec(getRandomEntityWithToken)
         }
       }
     }
   }

   /*
    * Get random entities by UUID
    */
   val getRandomEntityByUuidAnonymous = exec(
     http("GET entity by UUID (anonymous)")
       .get("/" + Settings.collection + "/${uuid}")
       .queryParamMap(Settings.queryParamMap)
       .headers(Headers.authAnonymous)
       .check(status.is(200))
   )

   val getRandomEntityByUuidWithToken = exec(
     http("GET entity by UUID (token)")
       .get("/" + Settings.collection + "/${uuid}")
       .queryParamMap(Settings.queryParamMap)
       .headers(Headers.authToken)
       .check(status.is(200))
   )

   val getRandomEntitiesByUuid = scenario("Get entities by uuid")
     .exec(injectTokenIntoSession())
     .exec(injectAuthType())
     .doIfOrElse(_ => Settings.endConditionType == EndConditionType.MinutesElapsed) {
       asLongAs(_ => Settings.continueMinutesTest) {
           feed(uuidFeeder())
             /*.exec{
             session => println(s"UUID: ${session("uuid").as[String]}")
             session
             }*/
             .tryMax(Settings.retryCount) {
             doIfOrElse(_ => Settings.authType == AuthType.Anonymous) {
               exec(getRandomEntityByUuidAnonymous)
             } {
               exec(getRandomEntityByUuidWithToken)
             }
           }
       }
     } {
       repeat(_ => Settings.endRequestCount.toInt) {
           feed(uuidFeeder())
             /*.exec {
             session => println(s"UUID: ${session("uuid").as[String]}")
             session
             }*/
             .tryMax(Settings.retryCount) {
               doIfOrElse(_ => Settings.authType == AuthType.Anonymous) {
                 exec(getRandomEntityByUuidAnonymous)
               } {
                 exec(getRandomEntityByUuidWithToken)
               }
             }
         }
     }

   /*
    * Create entities
    */
   val loadEntity = exec(
     doIf("${validEntity}", "yes") {
       exec(http("POST load entity")
         .post(_ => "/" + Settings.collection)
         .headers(Headers.authToken)
         .body(StringBody("""${entity}"""))
         // 200 for success, 400 if already exists
         .check(status.in(Seq(200)), extractCreateUuid(SessionVarUuid)))
         .exec(session => {
           Settings.addUuid(session("seededEntityNum").as[String].toInt, session(SessionVarUuid).as[String])
           session
         })
     }
   )

   val loadEntities = scenario("Load entities")
     .exec(injectTokenIntoSession())
     .exec(injectAuthType())
     .asLongAs(session => session("validEntity").asOption[String].map(validEntity => validEntity != "no").getOrElse[Boolean](true)) {
       feed(FeederGenerator.generateCustomEntityFeeder(Settings.numEntities, Settings.entityType, Settings.entityPrefix, Settings.entitySeed))
         /*.exec{
           session => if (session("validEntity").as[String] == "yes") { println("Loading entity #" + session("entityNum").as[String]) }
           session
         }*/
         .doIf(session => session("validEntity").as[String] == "yes") {
           tryMax(Settings.retryCount) {
             exec(loadEntity)
           }
         }
     }

   /*
    * Delete entities
    */
   val deleteEntity = exec(
     http("DELETE entity")
       .delete("""${entityUrl}""")
       .headers(Headers.authToken)
       // 200 for success, 404 if doesn't exist
       .check(status.in(Seq(200)))
   )

   val deleteEntities = scenario("Delete entities")
     .exec(injectTokenIntoSession())
     .exec(injectAuthType())
     .asLongAs(session => session("validEntity").asOption[String].map(validEntity => validEntity != "no").getOrElse[Boolean](true)) {
     feed(FeederGenerator.generateCustomEntityFeeder(Settings.numEntities, Settings.entityType, Settings.entityPrefix, Settings.entitySeed))
       /*.exec {
       session => if (session("validEntity").as[String] == "yes") { println("Deleting entity #" + session("entityNum").as[String]) }
         session
       }*/
       .doIf(session => session("validEntity").as[String] == "yes") {
         tryMax(Settings.retryCount) {
           exec(deleteEntity)
         }
       }
   }

   /*
    * Update entities
    */
   val updateEntity = exec(
     http("UPDATE entity")
       .put("""${entityUrl}""")
       .headers(Headers.authToken)
       .body(StringBody(Settings.updateBody))
       // 200 for success, 404 if doesn't exist
       .check(status.in(Seq(200)))
   )

   val updateEntities = scenario("Update entities")
     .exec(injectTokenIntoSession())
     .exec(injectAuthType())
     .asLongAs(session => session("validEntity").asOption[String].map(validEntity => validEntity != "no").getOrElse[Boolean](true)) {
       feed(FeederGenerator.generateCustomEntityFeeder(Settings.numEntities, Settings.entityType, Settings.entityPrefix, Settings.entitySeed))
         /*.exec {
           session => if (session("validEntity").as[String] == "yes") { println("Updating entity #" + session("entityNum").as[String]) }
           session
         }*/
         .doIf(session => session("validEntity").as[String] == "yes") {
           exec(updateEntity)
         }
     }

   /*
    * Get by name sequential
    */
   val getEntityByNameSequentialAnonymous = exec(
     doIf("${validEntity}", "yes") {
       exec(http("GET entity by name sequential (anonymous)")
         .get("/" + Settings.collection + "/${entityName}")
         .queryParamMap(Settings.queryParamMap)
         .headers(Headers.authAnonymous)
         .check(status.is(200), extractCreateUuid(SessionVarUuid)))
         .exec(session => {
           Settings.addUuid(session("seededEntityNum").as[String].toInt, session(SessionVarUuid).as[String])
           session
         })
     }
   )

   val getEntityByNameSequentialWithToken = exec(
     doIf("${validEntity}", "yes") {
       exec(http("GET entity by name sequential (anonymous)")
         .get("/" + Settings.collection + "/${entityName}")
         .queryParamMap(Settings.queryParamMap)
         .headers(Headers.authToken)
         .check(status.is(200), extractCreateUuid(SessionVarUuid)))
         .exec(session => {
         Settings.addUuid(session("seededEntityNum").as[String].toInt, session(SessionVarUuid).as[String])
         session
       })
     }
   )

   val getEntitiesByNameSequential = scenario("Get entities by name sequentially")
     .exec(injectTokenIntoSession())
     .exec(injectAuthType())
     .asLongAs(session => session("validEntity").asOption[String].map(validEntity => validEntity != "no").getOrElse[Boolean](true)) {
       feed(FeederGenerator.generateCustomEntityFeeder(Settings.numEntities, Settings.entityType, Settings.entityPrefix, Settings.entitySeed))
         /*.exec{
           session => if (session("validEntity").as[String] == "yes") { println("Loading entity #" + session("entityNum").as[String]) }
           session
         }*/
         .doIf(session => session("validEntity").as[String] == "yes") {
           tryMax(Settings.retryCount) {
             doIfOrElse(_ => Settings.authType == AuthType.Anonymous) {
               exec(getEntityByNameSequentialAnonymous)
             } {
               exec(getEntityByNameSequentialWithToken)
             }
           }
         }
     }

   val doNothing = scenario("Do Nothing").exec(http("Get Page").get("http://google.com"))

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.apache.usergrid.scenarios

	import io.gatling.core.Predef._
	import io.gatling.core.feeder.RecordSeqFeederBuilder
	import io.gatling.http.Predef._
	import org.apache.usergrid.datagenerators.FeederGenerator
	import org.apache.usergrid.enums.{CsvFeedPatternType, EndConditionType, AuthType}
	import org.apache.usergrid.helpers.Extractors._
	import org.apache.usergrid.helpers.{Headers, Utils}
	import org.apache.usergrid.settings.Settings

	/**
	* Provides CRUD methods for custom entities
	*
	*
	*
	*/
	object EntityCollectionScenarios {

	//The value for the cursor
	val SessionVarCursor: String = "cursor"
	val SessionVarUuid: String = "createUuid"

	def entityGetUrl(useCursor: Boolean): String = {
	val url = s"/${Settings.collection}?" +
	(if (useCursor) "cursor=${" + SessionVarCursor + "}&" else "") +
	(if (Settings.searchQuery != "") s"ql=${Settings.searchQuery}&" else "") +
	(if (Settings.searchLimit > 0) s"limit=${Settings.searchLimit}&" else "")

	// remove trailing & or ?
	url.dropRight(1)
	}

	def entityGetByNameUrl(entityName: String): String = {

	s"/${Settings.collection}/$entityName"
	}

	def randomEntityNameUrl(prefix: String = Settings.entityPrefix, numEntities: Int = Settings.numEntities, seed: Int = Settings.entitySeed): String = {

	Utils.randomEntityNameUrl(prefix, numEntities, seed, Settings.baseCollectionUrl)
	}

	def uuidFeeder(): RecordSeqFeederBuilder[String] = {
	if (Settings.csvFeedPattern == CsvFeedPatternType.Circular) {
	csv(Settings.feedUuidFilename).circular
	} else {
	csv(Settings.feedUuidFilename).random
	}
	}

	/*
	* Loop through entities using cursor
	*/
	val getEntitiesWithoutCursor = exec(
	http("GET entities")
	.get(entityGetUrl(false))
	.headers(Headers.authToken)
	.check(status.is(200), maybeExtractCursor(SessionVarCursor))
	)

	val getEntitiesWithCursor = exec(
	http("GET entities")
	.get(entityGetUrl(true))
	.headers(Headers.authToken)
	.check(status.is(200), maybeExtractCursor(SessionVarCursor))
	)

	val getEntityPagesToEnd = scenario("Get all entities")
	.exec(injectTokenIntoSession())
	.exec(injectAuthType())
	.doIfOrElse(_ => Settings.endConditionType == EndConditionType.MinutesElapsed) {
	asLongAs(_ => Settings.continueMinutesTest, exitASAP = true) {
	exec(getEntitiesWithoutCursor)
	.asLongAs(stringParamExists(SessionVarCursor)) {
	exec(getEntitiesWithCursor)
	}
	}
	} {
	repeat(_ => Settings.endRequestCount.toInt) {
	exec(getEntitiesWithoutCursor)
	.asLongAs(stringParamExists(SessionVarCursor)) {
	exec(getEntitiesWithCursor)
	}
	}
	}
	//.exec(sessionFunction => { sessionFunction })

	/*
	* Get random entities by name
	*/
	val getRandomEntityAnonymous = exec(
	http("GET entity by name (anonymous)")
	.get(randomEntityNameUrl())
	.headers(Headers.authAnonymous)
	.check(status.is(200))
	)

	val getRandomEntityWithToken = exec(
	http("GET entity by name (token)")
	.get(randomEntityNameUrl())
	.headers(Headers.authToken)
	.check(status.is(200))
	)

	val getRandomEntitiesByName = scenario("Get entities by name randomly")
	.exec(injectTokenIntoSession())
	.exec(injectAuthType())
	.doIfOrElse(_ => Settings.endConditionType == EndConditionType.MinutesElapsed) {
	asLongAs(_ => Settings.continueMinutesTest) {
	tryMax(Settings.retryCount) {
	doIfOrElse(_ => Settings.authType == AuthType.Anonymous) {
	exec(getRandomEntityAnonymous)
	} {
	exec(getRandomEntityWithToken)
	}
	}
	}
	} {
	repeat(_ => Settings.endRequestCount.toInt) {
	tryMax(Settings.retryCount) {
	doIfOrElse(_ => Settings.authType == AuthType.Anonymous) {
	exec(getRandomEntityAnonymous)
	} {
	exec(getRandomEntityWithToken)
	}
	}
	}
	}

	/*
	* Get random entities by UUID
	*/
	val getRandomEntityByUuidAnonymous = exec(
	http("GET entity by UUID (anonymous)")
	.get("/" + Settings.collection + "/${uuid}")
	.queryParamMap(Settings.queryParamMap)
	.headers(Headers.authAnonymous)
	.check(status.is(200))
	)

	val getRandomEntityByUuidWithToken = exec(
	http("GET entity by UUID (token)")
	.get("/" + Settings.collection + "/${uuid}")
	.queryParamMap(Settings.queryParamMap)
	.headers(Headers.authToken)
	.check(status.is(200))
	)

	val getRandomEntitiesByUuid = scenario("Get entities by uuid")
	.exec(injectTokenIntoSession())
	.exec(injectAuthType())
	.doIfOrElse(_ => Settings.endConditionType == EndConditionType.MinutesElapsed) {
	asLongAs(_ => Settings.continueMinutesTest) {
	feed(uuidFeeder())
	/*.exec{
	session => println(s"UUID: ${session("uuid").as[String]}")
	session
	}*/
	.tryMax(Settings.retryCount) {
	doIfOrElse(_ => Settings.authType == AuthType.Anonymous) {
	exec(getRandomEntityByUuidAnonymous)
	} {
	exec(getRandomEntityByUuidWithToken)
	}
	}
	}
	} {
	repeat(_ => Settings.endRequestCount.toInt) {
	feed(uuidFeeder())
	/*.exec {
	session => println(s"UUID: ${session("uuid").as[String]}")
	session
	}*/
	.tryMax(Settings.retryCount) {
	doIfOrElse(_ => Settings.authType == AuthType.Anonymous) {
	exec(getRandomEntityByUuidAnonymous)
	} {
	exec(getRandomEntityByUuidWithToken)
	}
	}
	}
	}

	/*
	* Create entities
	*/
	val loadEntity = exec(
	doIf("${validEntity}", "yes") {
	exec(http("POST load entity")
	.post(_ => "/" + Settings.collection)
	.headers(Headers.authToken)
	.body(StringBody("""${entity}"""))
	// 200 for success, 400 if already exists
	.check(status.in(Seq(200)), extractCreateUuid(SessionVarUuid)))
	.exec(session => {
	Settings.addUuid(session("seededEntityNum").as[String].toInt, session(SessionVarUuid).as[String])
	session
	})
	}
	)

	val loadEntities = scenario("Load entities")
	.exec(injectTokenIntoSession())
	.exec(injectAuthType())
	.asLongAs(session => session("validEntity").asOption[String].map(validEntity => validEntity != "no").getOrElse[Boolean](true)) {
	feed(FeederGenerator.generateCustomEntityFeeder(Settings.numEntities, Settings.entityType, Settings.entityPrefix, Settings.entitySeed))
	/*.exec{
	session => if (session("validEntity").as[String] == "yes") { println("Loading entity #" + session("entityNum").as[String]) }
	session
	}*/
	.doIf(session => session("validEntity").as[String] == "yes") {
	tryMax(Settings.retryCount) {
	exec(loadEntity)
	}
	}
	}

	/*
	* Delete entities
	*/
	val deleteEntity = exec(
	http("DELETE entity")
	.delete("""${entityUrl}""")
	.headers(Headers.authToken)
	// 200 for success, 404 if doesn't exist
	.check(status.in(Seq(200)))
	)

	val deleteEntities = scenario("Delete entities")
	.exec(injectTokenIntoSession())
	.exec(injectAuthType())
	.asLongAs(session => session("validEntity").asOption[String].map(validEntity => validEntity != "no").getOrElse[Boolean](true)) {
	feed(FeederGenerator.generateCustomEntityFeeder(Settings.numEntities, Settings.entityType, Settings.entityPrefix, Settings.entitySeed))
	/*.exec {
	session => if (session("validEntity").as[String] == "yes") { println("Deleting entity #" + session("entityNum").as[String]) }
	session
	}*/
	.doIf(session => session("validEntity").as[String] == "yes") {
	tryMax(Settings.retryCount) {
	exec(deleteEntity)
	}
	}
	}

	/*
	* Update entities
	*/
	val updateEntity = exec(
	http("UPDATE entity")
	.put("""${entityUrl}""")
	.headers(Headers.authToken)
	.body(StringBody(Settings.updateBody))
	// 200 for success, 404 if doesn't exist
	.check(status.in(Seq(200)))
	)

	val updateEntities = scenario("Update entities")
	.exec(injectTokenIntoSession())
	.exec(injectAuthType())
	.asLongAs(session => session("validEntity").asOption[String].map(validEntity => validEntity != "no").getOrElse[Boolean](true)) {
	feed(FeederGenerator.generateCustomEntityFeeder(Settings.numEntities, Settings.entityType, Settings.entityPrefix, Settings.entitySeed))
	/*.exec {
	session => if (session("validEntity").as[String] == "yes") { println("Updating entity #" + session("entityNum").as[String]) }
	session
	}*/
	.doIf(session => session("validEntity").as[String] == "yes") {
	exec(updateEntity)
	}
	}

	/*
	* Get by name sequential
	*/
	val getEntityByNameSequentialAnonymous = exec(
	doIf("${validEntity}", "yes") {
	exec(http("GET entity by name sequential (anonymous)")
	.get("/" + Settings.collection + "/${entityName}")
	.queryParamMap(Settings.queryParamMap)
	.headers(Headers.authAnonymous)
	.check(status.is(200), extractCreateUuid(SessionVarUuid)))
	.exec(session => {
	Settings.addUuid(session("seededEntityNum").as[String].toInt, session(SessionVarUuid).as[String])
	session
	})
	}
	)

	val getEntityByNameSequentialWithToken = exec(
	doIf("${validEntity}", "yes") {
	exec(http("GET entity by name sequential (anonymous)")
	.get("/" + Settings.collection + "/${entityName}")
	.queryParamMap(Settings.queryParamMap)
	.headers(Headers.authToken)
	.check(status.is(200), extractCreateUuid(SessionVarUuid)))
	.exec(session => {
	Settings.addUuid(session("seededEntityNum").as[String].toInt, session(SessionVarUuid).as[String])
	session
	})
	}
	)

	val getEntitiesByNameSequential = scenario("Get entities by name sequentially")
	.exec(injectTokenIntoSession())
	.exec(injectAuthType())
	.asLongAs(session => session("validEntity").asOption[String].map(validEntity => validEntity != "no").getOrElse[Boolean](true)) {
	feed(FeederGenerator.generateCustomEntityFeeder(Settings.numEntities, Settings.entityType, Settings.entityPrefix, Settings.entitySeed))
	/*.exec{
	session => if (session("validEntity").as[String] == "yes") { println("Loading entity #" + session("entityNum").as[String]) }
	session
	}*/
	.doIf(session => session("validEntity").as[String] == "yes") {
	tryMax(Settings.retryCount) {
	doIfOrElse(_ => Settings.authType == AuthType.Anonymous) {
	exec(getEntityByNameSequentialAnonymous)
	} {
	exec(getEntityByNameSequentialWithToken)
	}
	}
	}
	}

	val doNothing = scenario("Do Nothing").exec(http("Get Page").get("http://google.com"))

	}