otf-service-api/src/test/java/org/oran/otf/api/tests/shared/MemoryDatabase.java

   1 /*  Copyright (c) 2019 AT&T Intellectual Property.                             #\r
   2 #                                                                              #\r
   3 #   Licensed under the Apache License, Version 2.0 (the "License");            #\r
   4 #   you may not use this file except in compliance with the License.           #\r
   5 #   You may obtain a copy of the License at                                    #\r
   6 #                                                                              #\r
   7 #       http://www.apache.org/licenses/LICENSE-2.0                             #\r
   8 #                                                                              #\r
   9 #   Unless required by applicable law or agreed to in writing, software        #\r
  10 #   distributed under the License is distributed on an "AS IS" BASIS,          #\r
  11 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #\r
  12 #   See the License for the specific language governing permissions and        #\r
  13 #   limitations under the License.                                             #\r
  14 ##############################################################################*/\r
  15 \r
  16 \r
  17 package org.oran.otf.api.tests.shared;\r
  18 \r
  19 import org.oran.otf.common.model.*;\r
  20 import org.oran.otf.common.model.local.BpmnInstance;\r
  21 import org.oran.otf.common.model.local.UserGroup;\r
  22 import com.mongodb.BasicDBObjectBuilder;\r
  23 import com.mongodb.DBObject;\r
  24 import com.mongodb.MongoClient;\r
  25 import de.flapdoodle.embed.mongo.Command;\r
  26 import de.flapdoodle.embed.mongo.MongodExecutable;\r
  27 import de.flapdoodle.embed.mongo.MongodProcess;\r
  28 import de.flapdoodle.embed.mongo.MongodStarter;\r
  29 import de.flapdoodle.embed.mongo.config.DownloadConfigBuilder;\r
  30 import de.flapdoodle.embed.mongo.config.ExtractedArtifactStoreBuilder;\r
  31 import de.flapdoodle.embed.mongo.config.IMongodConfig;\r
  32 import de.flapdoodle.embed.mongo.config.MongodConfigBuilder;\r
  33 import de.flapdoodle.embed.mongo.config.Net;\r
  34 import de.flapdoodle.embed.mongo.config.RuntimeConfigBuilder;\r
  35 import de.flapdoodle.embed.mongo.distribution.Version;\r
  36 import de.flapdoodle.embed.mongo.distribution.Version.Main;\r
  37 import de.flapdoodle.embed.process.config.IRuntimeConfig;\r
  38 import de.flapdoodle.embed.process.config.store.HttpProxyFactory;\r
  39 import de.flapdoodle.embed.process.runtime.Network;\r
  40 \r
  41 import java.sql.Timestamp;\r
  42 import java.util.ArrayList;\r
  43 import java.util.Arrays;\r
  44 import java.util.Date;\r
  45 import java.util.List;\r
  46 import java.util.Random;\r
  47 import javassist.util.proxy.ProxyFactory;\r
  48 import org.apache.commons.lang3.time.DateUtils;\r
  49 import org.apache.http.HttpResponse;\r
  50 import org.apache.http.client.methods.HttpGet;\r
  51 import org.oran.otf.common.model.*;\r
  52 import org.springframework.context.annotation.Configuration;\r
  53 import org.bson.types.ObjectId;\r
  54 import org.springframework.data.mongodb.core.MongoTemplate;\r
  55 import org.springframework.data.mongodb.core.query.Criteria;\r
  56 import org.springframework.data.mongodb.core.query.Query;\r
  57 import org.springframework.test.context.ActiveProfiles;\r
  58 \r
  59 \r
  60 @ActiveProfiles("test")\r
  61 public abstract class MemoryDatabase {\r
  62   protected static MongodExecutable mongodExecutable;\r
  63   protected static MongoTemplate mongoTemplate;\r
  64 \r
  65   //TODO use mongod process to be response from mongodExecutable.start(), on pulbic calls check if null if so call setup else dont\r
  66   protected static MongodProcess mongod = null;\r
  67 \r
  68   protected static Query userQuery = new Query(Criteria.where("firstName").is("Mech"));\r
  69   //protected static Query mechUserQuery = new Query(Criteria.where("firstName").is("Mech"));\r
  70   protected static Query testInstanceQuery = new Query(Criteria.where("testInstanceName").is("MechTestInstance"));\r
  71   protected static Query groupQuery = new Query(Criteria.where("groupName").is("MechGroup"));\r
  72   protected static Query testDefQuery = new Query(Criteria.where("testName").is("MechTestDefinition"));\r
  73 \r
  74   //values should match with DataConfig2\r
  75   protected static int port=5555;\r
  76   protected static String host="localhost";\r
  77 \r
  78 \r
  79   public static void setup()throws Exception{\r
  80     Command command = Command.MongoD;\r
  81     IRuntimeConfig runtimeConfig = new RuntimeConfigBuilder()\r
  82         .defaults(command)\r
  83         .artifactStore(new ExtractedArtifactStoreBuilder()\r
  84             .defaults(command)\r
  85             .download(new DownloadConfigBuilder()\r
  86                 .defaultsForCommand(command)\r
  87                 .proxyFactory(new HttpProxyFactory("localhost",8080))))\r
  88              .build();\r
  89 \r
  90     //String host = "localhost";\r
  91     //int port = 5555;\r
  92 \r
  93     IMongodConfig mongodConfig = new MongodConfigBuilder().version(Main.PRODUCTION)\r
  94         .net(new Net(host, port, Network.localhostIsIPv6()))\r
  95         .build();\r
  96     //MongodStarter starter = MongodStarter.getDefaultInstance();\r
  97     MongodStarter starter = MongodStarter.getInstance(runtimeConfig);\r
  98     mongodExecutable = starter.prepare(mongodConfig);\r
  99     mongodExecutable.start();\r
 100     mongoTemplate = new MongoTemplate(new MongoClient(host, port), "test");\r
 101 \r
 102     DBObject objectToSave = BasicDBObjectBuilder.start()\r
 103         .add("name", "john")\r
 104         .get();\r
 105     mongoTemplate.save(objectToSave, "collection");\r
 106 \r
 107 \r
 108   }\r
 109   /*\r
 110   public static User createMechUser(){\r
 111 \r
 112     User user = mongoTemplate.findOne(mechUserQuery, User.class);\r
 113     if(user == null) {\r
 114       user = new User();\r
 115       user.setFirstName("Mech");\r
 116       user.setLastName("Id");\r
 117       user.setEmail("email@localhost");\r
 118       mongoTemplate.save(user, "users");\r
 119       user = mongoTemplate.findOne(mechUserQuery, User.class);\r
 120     }\r
 121     return user;\r
 122   }\r
 123 \r
 124    */\r
 125   //TODO: make admin user be the mechid, this is because of AAF test will fail if random user is used\r
 126   private static User createMechUserIfNotExists(){\r
 127     User user = mongoTemplate.findOne(userQuery, User.class);\r
 128     if(user == null) {\r
 129       user = new User();\r
 130       user.setFirstName("Mech");\r
 131       user.setLastName("Id");\r
 132       user.setEmail("email@localhost");\r
 133       mongoTemplate.save(user, "users");\r
 134       user = mongoTemplate.findOne(userQuery, User.class);\r
 135     }\r
 136     return user;\r
 137 \r
 138   }\r
 139   private static Group createMechGroupIfNotExists(){\r
 140     User user = MemoryDatabase.createMechUserIfNotExists();\r
 141     Group group = mongoTemplate.findOne(groupQuery, Group.class);\r
 142     if(group == null) {\r
 143       String groupName = "MechGroup";\r
 144       group = new Group();\r
 145       group.setOwnerId(user.get_id());\r
 146       group.setGroupName(groupName);\r
 147       group.setGroupDescription(groupName + " description");\r
 148       mongoTemplate.save(group, "groups");\r
 149       group = mongoTemplate.findOne(groupQuery, Group.class);\r
 150     }\r
 151     return group;\r
 152   }\r
 153   private static TestDefinition createMechTestDefinitionIfNotExists(){\r
 154     TestDefinition testDefinition = mongoTemplate.findOne(testDefQuery, TestDefinition.class);\r
 155     if(testDefinition == null){\r
 156 \r
 157       BpmnInstance bpmnInstance = new BpmnInstance();\r
 158       bpmnInstance.setDeployed(true);\r
 159       bpmnInstance.setVersion(1);\r
 160       List list = new ArrayList(Arrays.asList(bpmnInstance));\r
 161 \r
 162       testDefinition = new TestDefinition();\r
 163       testDefinition.setDisabled(false);\r
 164       testDefinition.setBpmnInstances(list);\r
 165       testDefinition.setTestName("MechTestDefinition");\r
 166       testDefinition.setTestDescription("MechTestDefinition description");\r
 167       testDefinition.setProcessDefinitionKey("MechTestDefinitionKey");\r
 168       testDefinition.setCreatedBy(createMechUserIfNotExists().get_id());\r
 169       testDefinition.setGroupId(createMechGroupIfNotExists().get_id());\r
 170       testDefinition.setCreatedAt(new Timestamp(new Date().getTime()));\r
 171       testDefinition.setUpdatedAt(new Timestamp(new Date().getTime()));\r
 172       mongoTemplate.save(testDefinition, "testDefinitions");\r
 173       testDefinition = mongoTemplate.findOne(testDefQuery, TestDefinition.class);\r
 174     }\r
 175     return testDefinition;\r
 176 \r
 177   }\r
 178 \r
 179 \r
 180   private static TestInstance createMechTestInstanceIfNotExists(){\r
 181     TestInstance testInstance = mongoTemplate.findOne(testInstanceQuery, TestInstance.class);\r
 182     User user = createMechUserIfNotExists();\r
 183     UserGroup userGroup = new UserGroup();\r
 184     if(testInstance == null){\r
 185       testInstance = new TestInstance();\r
 186       testInstance.setTestInstanceName("MechTestInstance");\r
 187       testInstance.setTestInstanceDescription("MechTestInstance description");\r
 188       testInstance.setCreatedBy(user.get_id());\r
 189       testInstance.setGroupId(createMechGroupIfNotExists().get_id());\r
 190       testInstance.setTestDefinitionId(createMechTestDefinitionIfNotExists().get_id());\r
 191       testInstance.setMaxExecutionTimeInMillis(new Random().nextInt(5000));\r
 192       testInstance.setUseLatestTestDefinition(true);\r
 193       mongoTemplate.save(testInstance, "testInstances");\r
 194       testInstance = mongoTemplate.findOne(testInstanceQuery, TestInstance.class);\r
 195     }\r
 196     userGroup.setGroupId(testInstance.getGroupId());\r
 197     userGroup.setPermissions(Arrays.asList("Admin"));\r
 198     user.setGroups(Arrays.asList(userGroup));\r
 199     mongoTemplate.save(user, "users");\r
 200     return testInstance;\r
 201   }\r
 202 \r
 203   public static void createGroups(){\r
 204 \r
 205     MemoryDatabase.createMechUserIfNotExists();\r
 206     List<String> groupNames = new ArrayList<>(Arrays.asList("Group1", "Group2", "Group3", "Group4", "Group5"));\r
 207     groupNames.forEach(name->{\r
 208       Group group = new Group();\r
 209       User usr = mongoTemplate.findOne(userQuery, User.class);\r
 210       group.setOwnerId(usr.get_id());\r
 211       group.setGroupName(name);\r
 212       group.setGroupDescription(name + " description");\r
 213       mongoTemplate.save(group, "groups");\r
 214     });\r
 215 \r
 216   }\r
 217 \r
 218   public static void createGroupsForPermission()\r
 219   {\r
 220     Group parentGroup = new Group();\r
 221     Group firstChildGroup = new Group();\r
 222     Group childOfChildGroup = new Group();\r
 223     parentGroup.setGroupName("parent group");\r
 224     firstChildGroup.setGroupName("first child group");\r
 225     childOfChildGroup.setGroupName("child of child group");\r
 226     Role adminRole = new Role();\r
 227     Role devRole = new Role();\r
 228     Role executorRole = new Role();\r
 229     GroupMember parentMember = new GroupMember();\r
 230     GroupMember firstChildMember = new GroupMember();\r
 231     GroupMember childOfChildMember = new GroupMember();\r
 232     //set up members\r
 233     createUsers();\r
 234     List<User> users = mongoTemplate.findAll(User.class,"users"); // this should be atleast 3 users\r
 235     /*\r
 236     set up\r
 237     parent group -> members only with admin roles. Permission = "READ","WRITE","MANAGEMENT"\r
 238     child group -> members only with admin and dev roles. Permission = "READ","WRITE", "MANAGEMENT\r
 239     child of child group -> members with only executor roles. Permission = "EXECUTE\r
 240      */\r
 241     parentMember.setUserId(users.get(0).get_id());\r
 242     parentMember.setRoles(Arrays.asList("admin"));\r
 243     firstChildMember.setUserId(users.get(1).get_id());\r
 244     firstChildMember.setRoles(Arrays.asList("dev","admin"));\r
 245     childOfChildMember.setUserId(users.get(2).get_id());\r
 246     childOfChildMember.setRoles(Arrays.asList("executor"));\r
 247     //set up roles\r
 248     adminRole.setRoleName("admin");\r
 249     adminRole.setPermissions(Arrays.asList("READ","WRITE","MANAGEMENT"));\r
 250     devRole.setRoleName("dev");\r
 251     devRole.setPermissions(Arrays.asList("READ","WRITE"));\r
 252     executorRole.setRoleName("executor");\r
 253     executorRole.setPermissions(Arrays.asList("EXECUTE"));\r
 254     List<Role> defaultRoles = new ArrayList<>();\r
 255     defaultRoles.add(devRole);\r
 256     defaultRoles.add(adminRole);\r
 257     defaultRoles.add(executorRole);\r
 258     //set up groups\r
 259     parentGroup.setRoles(defaultRoles);\r
 260     parentGroup.setMembers(Arrays.asList(parentMember));\r
 261     firstChildGroup.setRoles(defaultRoles);\r
 262     firstChildGroup.setMembers(Arrays.asList(firstChildMember));\r
 263     childOfChildGroup.setRoles(defaultRoles);\r
 264     childOfChildGroup.setMembers(Arrays.asList(childOfChildMember));\r
 265     /*\r
 266       set up parent tree\r
 267       structure:\r
 268       parentGroup\r
 269           |\r
 270       Child group\r
 271           |\r
 272       Child of child group\r
 273      */\r
 274     mongoTemplate.save(parentGroup,"groups");\r
 275     mongoTemplate.save(firstChildGroup,"groups");\r
 276     mongoTemplate.save(childOfChildGroup,"groups");\r
 277     // query object so we can get the object id and set up parent ids\r
 278     Query parentQ = new Query(Criteria.where("groupName").is("parent group"));\r
 279     Query firstChildQ = new Query(Criteria.where("groupName").is("first child group"));\r
 280     Query childOfChildQ = new Query(Criteria.where("groupName").is("child of child group"));\r
 281     Group parentGroupDbObj = mongoTemplate.findOne(parentQ,Group.class);\r
 282     Group firstChildDbObj = mongoTemplate.findOne(firstChildQ,Group.class);\r
 283     Group childOfChildDbObj = mongoTemplate.findOne(childOfChildQ,Group.class);\r
 284 \r
 285     firstChildDbObj.setParentGroupId(parentGroupDbObj.get_id());\r
 286     childOfChildDbObj.setParentGroupId(firstChildDbObj.get_id());\r
 287     mongoTemplate.save(firstChildDbObj);\r
 288     mongoTemplate.save(childOfChildDbObj);\r
 289   }\r
 290 \r
 291   public static void createUsers(){\r
 292     List<String> usersFirstNames = new ArrayList<>(Arrays.asList("Joe", "Jim", "Rick", "David", "Tony"));\r
 293     List<String> usersLastNames = new ArrayList<>(Arrays.asList("Terry", "Roll", "Luis", "Perry"));\r
 294       usersFirstNames.forEach(name->{\r
 295         User user = new User();\r
 296         int index = new Random().nextInt(usersFirstNames.size()-1);\r
 297         user.setEmail(name+usersLastNames.get(index)+"@email.com");\r
 298         user.setLastName(name);\r
 299         user.setFirstName(usersLastNames.get(index));\r
 300         mongoTemplate.save(user, "users");\r
 301     });\r
 302 \r
 303   }\r
 304   public static void createTeatHeads(){\r
 305     List<String> testheadNames = new ArrayList<>(Arrays.asList("SSH", "FTP", "PING", "PROCESS", "daRudeSandstorm"));\r
 306     testheadNames.forEach(name->{\r
 307       String random = Integer.toString(new Random().nextInt(4000)+4000);\r
 308       TestHead testHead = new TestHead();\r
 309       testHead.setTestHeadName(name);\r
 310       testHead.setTestHeadDescription(name+" virtual test head ");\r
 311       testHead.setPort(random);\r
 312       testHead.setResourcePath("resources.vths.com/"+name);\r
 313       testHead.setHostname("resources.vths.com");\r
 314       testHead.setGroupId(createMechUserIfNotExists().get_id());\r
 315       testHead.setGroupId(createMechGroupIfNotExists().get_id());\r
 316       testHead.setCreatedAt(new Timestamp(new Date().getTime()));\r
 317       testHead.setUpdatedAt(new Timestamp(new Date().getTime()));\r
 318       mongoTemplate.save(testHead, "testHeads");\r
 319 \r
 320     });\r
 321   }\r
 322   public static void createTestDefinitions(){\r
 323     List<String> testDefinitionNames = new ArrayList<>(Arrays.asList("testDef1", "testDef2", "testDef3", "testDef4"));\r
 324     testDefinitionNames.forEach(name->{\r
 325       TestDefinition testDefinition = new TestDefinition();\r
 326       testDefinition.setDisabled(false);\r
 327       testDefinition.setTestName(name);\r
 328       testDefinition.setTestDescription(name+" description");\r
 329       testDefinition.setProcessDefinitionKey(name+"key");\r
 330       testDefinition.setCreatedBy(createMechUserIfNotExists().get_id());\r
 331       testDefinition.setGroupId(createMechGroupIfNotExists().get_id());\r
 332       testDefinition.setCreatedAt(new Timestamp(new Date().getTime()));\r
 333       testDefinition.setUpdatedAt(new Timestamp(new Date().getTime()));\r
 334       mongoTemplate.save(testDefinition, "testDefinitions");\r
 335     });\r
 336   }\r
 337   public static void createTestInstances(){\r
 338     List<String> testInstanceName = new ArrayList<>(Arrays.asList("TestInstance1", "TestInstance2", "TestInstance3", "TestInstance4"));\r
 339     testInstanceName.forEach(name->{\r
 340       TestInstance testInstance = new TestInstance();\r
 341       testInstance.setTestInstanceName(name);\r
 342       testInstance.setTestInstanceDescription(name+" description");\r
 343       testInstance.setCreatedBy(createMechUserIfNotExists().get_id());\r
 344       testInstance.setGroupId(createMechGroupIfNotExists().get_id());\r
 345       testInstance.setTestDefinitionId(createMechTestDefinitionIfNotExists().get_id());\r
 346       testInstance.setMaxExecutionTimeInMillis(new Random().nextInt(5000));\r
 347       testInstance.setUseLatestTestDefinition(true);\r
 348       mongoTemplate.save(testInstance, "testInstances");\r
 349     });\r
 350   }\r
 351 \r
 352   public static void createTestExecutions(){\r
 353     List<String> results = new ArrayList<>(Arrays.asList("COMPLETED", "FAILED", "PASSED", "INCOMPLETE"));\r
 354     results.forEach(result->{\r
 355       TestExecution testExecution = new TestExecution();\r
 356       testExecution.setAsync(false);\r
 357       testExecution.setExecutorId(createMechUserIfNotExists().get_id());\r
 358       testExecution.setGroupId(createMechGroupIfNotExists().get_id());\r
 359       testExecution.setStartTime(new Timestamp(new Date().getTime()));\r
 360       testExecution.setEndTime(new Timestamp(DateUtils.addHours(new Date(),3).getTime()));\r
 361       testExecution.setTestResult(result);\r
 362       testExecution.setTestResultMessage("Process result is: "+ result);\r
 363       mongoTemplate.save(testExecution, "testExecutions");\r
 364     });\r
 365   }\r
 366 \r
 367   public static void createAllAdmin(){\r
 368     createMechTestDefinitionIfNotExists();\r
 369     createMechTestInstanceIfNotExists();\r
 370   }\r
 371 \r
 372   public static void createAllTables()throws Exception{\r
 373     setup();\r
 374     createUsers();\r
 375     createGroups();\r
 376     createTeatHeads();\r
 377     createTestDefinitions();\r
 378     createTestInstances();\r
 379     createTestExecutions();\r
 380   }\r
 381 \r
 382   public static void cleanup(){\r
 383     mongodExecutable.stop();\r
 384   }\r
 385 \r
 386 }\r