private Product getTrialExtensionProduct(TrialInstanceUpdateDto trialInstanceUpdateDto) {
    Product product = null;
    if (isNullOrEmpty(trialInstanceUpdateDto.getProductShortName())) {
      if (trialInstanceUpdateDto.getProductId() != null) {
        if (productDao.exists(trialInstanceUpdateDto.getProductId())) {
          product = productDao.getReference(trialInstanceUpdateDto.getProductId());
        }
      }
    } else {
      product = productDao.findByShortName(trialInstanceUpdateDto.getProductShortName());
    }

    return product;
  }
Exemplo n.º 2
0
  @Test
  public void testGetActualUrl() {
    ProductVersion productVersion =
        productVersionDao.findByProductAndName(productDao.findByShortName("EAM"), "EAM-BC-3");
    User user = userDao.findByUsername(testUserName);
    Region region = regionDao.getReference(2L);
    final TrialDto trialDto =
        trialService.launchTrial(getRequestStub(), productVersion, user, region, Locale.US);
    String guid = trialDto.getGuid();
    String url = trialDto.getUrl();
    assertNotNull(guid);
    assertNotNull(url);
    final TrialInstance actual = trialInstanceDao.findById(trialDto.getId());
    assertEquals(guid, actual.getGuid());
    assertEquals(url, actual.getUrl());

    RedirectUrlDto redirectUrlDto = trialService.getActualUrl(guid);
    assertNotNull(redirectUrlDto);
    assertEquals(actual.getUrl(), redirectUrlDto.getRedirectUrl());
    List<UserTracking> data =
        userTrackingDao.findByTrackingTypeAndUser(TrackingType.PROXY_URL_HIT, user);
    assertNotNull(data);
    assertEquals(1, data.size());
    assertEquals(actual.getId(), data.get(0).getTargetObject());

    redirectUrlDto = trialService.getActualUrl(guid);
    assertEquals(actual.getUrl(), redirectUrlDto.getRedirectUrl());
    data = userTrackingDao.findByTrackingTypeAndUser(TrackingType.PROXY_URL_HIT, user);
    assertNotNull(data);
    assertEquals(2, data.size());
    assertEquals(actual.getId(), data.get(0).getTargetObject());
    assertEquals(actual.getId(), data.get(1).getTargetObject());
  }
Exemplo n.º 3
0
  @Test
  public void testRequestTrialApprove() {
    final MockHttpServletRequest requestStub = super.getRequestStub();

    List<ProductVersion> productVersions = new ArrayList<ProductVersion>();

    productVersions.add(
        productVersionDao.findByProductAndName(productDao.findByShortName("EAM"), "EAM-BC-3"));
    productVersions.add(
        productVersionDao.findByProductAndName(productDao.findByShortName("XM"), "XM-BC-3"));
    User user = userDao.findByUsername(testUserName);
    Region region = regionDao.findById(2L);
    Locale locale = Locale.US;
    String comment = "Test comment.";

    final NullEmailProvider emailProvider = new NullEmailProvider();
    trialEmailComponent.setEmailProvider(emailProvider);

    TrialRequest trialRequest =
        trialService.requestTrial(requestStub, productVersions, user, region, locale, comment);
    List<NullEmailProvider.EmailInfo> asyncEmails = emailProvider.getAsyncEmails();
    assertEquals("Verify email count", 2, asyncEmails.size());
    NullEmailProvider.EmailInfo emailInfo = asyncEmails.get(0);
    assertEquals(
        messageProvider.getMessage(
            StringDefs.MESSAGE_TRIAL_REQUEST_SUBJECT,
            trialEmailComponent.productNamesStrungForEmail(productVersions)),
        emailInfo.subject);
    assertTrue(
        emailInfo.text.contains(
            "Products: " + trialEmailComponent.productNamesStrungForEmail(productVersions)));
    assertTrue(emailInfo.text.contains("User: "******"Comment: " + comment));
    assertTrue(emailInfo.text.contains("Region: " + region.getName()));
    assertEquals(StringDefs.BC_LEADS_EMAIL, emailInfo.address);
    String done = trialService.approveTrialRequest(requestStub, trialRequest.getRequestKey());
    assertEquals("Done", done);

    try {
      trialService.deleteTrialRequest(trialRequest.getRequestKey());
      fail("Delete should fail, as it has already been deleted.");
    } catch (DataAccessException dae) {
      // eat.
    }
  }
Exemplo n.º 4
0
  @Test
  public void testAddTrialEnvironment() throws Exception {
    loginTestUser();
    List<TrialEnvironment> environments = trialService.getEnvironments(1L);
    int enviroSize = environments.size();

    User user = new User();
    user.setUsername("*****@*****.**");
    user.setFirstName("Test");
    user.setLastName("Test");
    user.setCreatedAt(new Date());
    user.getRoles().add(Role.ROLE_EXTERNAL);
    user.setPassword(securityService.encodePassword("test", user.getCreatedAt()));
    userDao.save(user);

    Product product = new Product();
    product.setShortName("Test");
    product.setName("Test Long");

    productService.addProduct(product);

    ProductVersion productVersion = new ProductVersion();
    productVersion.setName("Test-version");
    productVersion.setCreatedAt(new Date());
    productVersion.setProduct(product);
    productVersion.setIeOnly(true);
    productVersionDao.save(productVersion);
    product.getProductVersions().add(productVersion);
    productDao.save(product);

    emService.flush();

    TrialDto trial = new TrialDto();
    trial.setProductId(product.getId());
    trial.setProductVersionId(productVersion.getId());
    trial.setUserId(user.getId());
    trial.setUrl("http://test/hahahaha");
    trial.setUsername("test");
    trial.setPassword("haha");
    trialService.createTrialEnvironment(trial);
    emService.flush();

    environments = trialService.getEnvironments(product.getId());
    assertEquals(enviroSize + 1, environments.size());
  }
Exemplo n.º 5
0
  @Test
  public void testTrialProductChild() throws Exception {
    assertEquals(3, trialProductChildDao.count());
    ProductVersion productVersion =
        productVersionDao.findByProductAndName(productDao.findByShortName("EAM"), "EAM-BC-3");
    TrialEnvironment environment =
        trialEnvironmentDao
            .findByProductVersionAndRegionAndAvailable(
                productVersion, regionDao.findByShortName("NA"), true)
            .get(0);
    for (TrialProductChild tpc :
        trialProductChildDao.findByRegion(regionDao.findByShortName("NA"))) {

      logger.error("tpc.id:" + tpc.getId());
      logger.error("tpc.getChildVersion().getName():" + tpc.getChildVersion().getName());
      logger.error("tpc.getParentVersion().getName():" + tpc.getParentVersion().getName());
    }
    assertEquals(
        "3 records for region:NA",
        3,
        trialProductChildDao.findByRegion(regionDao.findByShortName("NA")).size());
    assertEquals(
        "3 records with WS as parent",
        3,
        trialProductChildDao
            .findByRegionAndParentVersion(
                regionDao.findByShortName("NA"), productVersionDao.findByName("WS-BC-3"))
            .size());
    assertEquals(
        "1 record with EAM as child",
        1,
        trialProductChildDao
            .findByRegionAndChildVersion(regionDao.findByShortName("NA"), productVersion)
            .size());
    assertEquals(
        "2 records should come back for EAM delete",
        2,
        trialObjectsCreatorComponent
            .deleteEnvironmentAndRelations(
                productVersion, regionDao.findByShortName("NA"), environment)
            .size());
  }
Exemplo n.º 6
0
  @Test
  public void testRequestTrialSize() {

    final MockHttpServletRequest requestStub = super.getRequestStub();
    List<ProductVersion> productVersions = new ArrayList<ProductVersion>();
    productVersions.add(
        productVersionDao.findByProductAndName(productDao.findByShortName("EAM"), "EAM-BC-3"));
    User user = userDao.findByUsername(testUserName);
    Region region = regionDao.findById(1L);
    Locale locale = Locale.US;
    String comment = "Test comment.";

    final NullEmailProvider emailProvider = new NullEmailProvider();
    trialEmailComponent.setEmailProvider(emailProvider);

    TrialRequest trialRequest =
        trialService.requestTrial(requestStub, productVersions, user, region, locale, comment);

    List<NullEmailProvider.EmailInfo> asyncEmails = emailProvider.getAsyncEmails();
    assertEquals(2, asyncEmails.size());
    NullEmailProvider.EmailInfo emailInfo = asyncEmails.get(0);
    assertEquals(
        messageProvider.getMessage(
            StringDefs.MESSAGE_TRIAL_REQUEST_SUBJECT,
            trialEmailComponent.productNamesStrungForEmail(productVersions)),
        emailInfo.subject);
    assertTrue(
        emailInfo.text.contains(
            "Products: " + trialEmailComponent.productNamesStrungForEmail(productVersions)));
    assertTrue(emailInfo.text.contains("User: "******"Comment: " + comment));
    assertTrue(emailInfo.text.contains("Region: " + region.getName()));
    logger.debug("\n----- EMAIL BODY --- \n" + emailInfo.text + "\n---------------");

    loginAdminUser();

    assertEquals(1, trialService.getTrialRequests().size());
    trialService.deleteTrialRequest(trialRequest.getRequestKey());
    assertEquals(0, trialService.getTrialRequests().size());
  }
  @Test
  public void testGetAdminDashboard() throws Exception {

    int oneMonthUserCount = 5;
    int oneDayUserCount = 5;
    int oneWeekUserCount = 5;

    Date now = new Date();

    GregorianCalendar cal = new GregorianCalendar();
    cal.setTime(now);
    // set two weeks back

    cal.add(GregorianCalendar.DATE, -1);
    Date yesterday = cal.getTime();
    long yesterdayOffset = userDao.countByActiveAndCreatedAt(true, yesterday);
    cal.add(GregorianCalendar.DATE, -5);
    Date winOneWeek = cal.getTime();
    cal.add(GregorianCalendar.DATE, -1);
    Date oneWeek = cal.getTime();
    long oneWeekOffset = userDao.countByActiveAndCreatedAt(true, oneWeek);
    cal.add(GregorianCalendar.DATE, -22);
    Date winOneMonth = cal.getTime();

    cal.add(GregorianCalendar.DATE, -2);
    Date oneMonth = cal.getTime();
    cal.add(GregorianCalendar.YEAR, -20);
    Date effectivelyForever = cal.getTime();

    long oneMonthOffset = userDao.countByActiveAndCreatedAt(true, oneMonth);
    long foreverOffset = userDao.countByActiveAndCreatedAt(true, effectivelyForever);

    long baseMonthUsers = oneMonthUserCount + oneWeekUserCount + oneDayUserCount;
    long baseWeekUsers = oneWeekUserCount + oneDayUserCount;

    ArrayList<User> allUsers = new ArrayList<>();
    logger.info("oneMonthUserCount:" + winOneMonth.getTime());
    logger.info("oneWeekUserCount:" + winOneWeek.getTime());
    logger.info("oneDayUserCount:" + now.getTime());
    allUsers.addAll(
        createUsers(
            winOneMonth, "fakedomain1.com", "first", "last", "password", oneMonthUserCount));
    allUsers.addAll(
        createUsers(winOneWeek, "fakedomain2.com", "first", "last", "password", oneWeekUserCount));
    allUsers.addAll(
        createUsers(now, "fakedomain3.com", "first", "last", "password", oneDayUserCount));

    loginAdminUser();
    userDao.save(allUsers);
    for (User user : allUsers) {
      logger.info("oneMonthUserCount:" + winOneMonth + ",millis:" + winOneMonth.getTime());
      logger.info("oneWeekUserCount:" + winOneWeek + ",millis:" + winOneWeek.getTime());
      logger.info("oneDayUserCount:" + now + ",millis:" + now.getTime());
      logger.info(
          "user["
              + user.getUsername()
              + "] createdAt:"
              + user.getCreatedAt()
              + " , millis:"
              + user.getCreatedAt().getTime());
    }
    Region region = regionDao.findById(1L);

    /*
     * TRIALS SECTION
     */
    List<Product> productsForTrial = productDao.findByTrialsAvailable(true);
    ArrayList<Long> validTrialProductIds = new ArrayList<>();
    for (Product product : productsForTrial) {

      ProductVersion productVersion = pickOne(product.getProductVersions(), region, false);

      if (productVersion == null) {
        continue;
      }
      validTrialProductIds.add(product.getId());

      HashSet<Long> dates = new HashSet<>();

      for (User user : allUsers) {
        loginAdminUser();
        dates.add(user.getCreatedAt().getTime());
        activateTrial(user.getUsername(), product);
        DeployRequestDto deployRequestDto =
            this.getTrialRequestFor(user, productVersion, region, user.getCreatedAt());
        login(user.getUsername(), "password");

        DeploymentStackDto retDto =
            deploymentService.deployMultipleProducts(getRequestStub(), deployRequestDto);
        TrialInstance instance = trialInstanceDao.findById(retDto.getId());
        assertEquals(instance.getCreatedAt(), user.getCreatedAt());
      }
      assertEquals(3, dates.size());
    }
    // END TRIALS SECTION

    /*
     *
     * DO DEPLOYMENTS
     * SECTION
     */

    loginAdminUser();

    // need something there :)
    addAWSCredentials(allUsers);
    // NEED TO VARY.  For now, we will do this with all products for everyone
    List<Long[]> productAndVersionIdList =
        this.getDtoProdAndVersionList(productDao.findAll(), region);
    int badUsers = 0;
    for (User user : allUsers) {
      AmazonCredentials amazonCredentials =
          amazonCredentialsDao.findByUserAndName(user, "Dummy Key");
      if (amazonCredentials == null) {
        badUsers++;
        continue;
      }
      loginAdminUser();
      activateDeploys(user, productAndVersionIdList);
      login(user.getUsername(), "password");
      DeployRequestDto reqDto =
          this.getDeployRequestFor(
              user, productAndVersionIdList, region, amazonCredentials, user.getCreatedAt());
      DeploymentStackDto result =
          deploymentService.deployMultipleProducts(getRequestStub(), reqDto);
      DeploymentStack stack = deploymentStackDao.findById(result.getId());
      assertEquals(
          "User and stack created at times should be ==",
          user.getCreatedAt(),
          stack.getCreatedAt());
    }
    assertEquals(0, badUsers);

    // END DO DEPLOYMENTS SECTION

    /*
     * TESTING THE RETURN
     */
    loginAdminUser();
    DashboardDto dashboardDto = dashboardService.getAdminDashboard();
    assertEquals(
        "Compare what trial count should be",
        (long) (validTrialProductIds.size() * allUsers.size()),
        (long) dashboardDto.getActiveInfor24());
    assertEquals(
        "Compare all users", foreverOffset + allUsers.size(), (long) dashboardDto.getUsersTotal());
    assertEquals(
        "Compare all time deployment count",
        (long) allUsers.size(),
        (long) dashboardDto.getAllTimeAws());
    assertEquals(
        "Compare all time trial count",
        (long) (validTrialProductIds.size() * allUsers.size()),
        (long) dashboardDto.getAllTimeInfor24());
    for (Long[] ids : productAndVersionIdList) {

      // SPECIFIC day/week/month checks for products
      assertEquals(
          "Compare deploy counts for day/productId:" + ids[0],
          (long) oneDayUserCount,
          (long) dashboardDto.getDay().getAwsDeploymentsByProduct().get(ids[0]));
      assertEquals(
          "Compare deploy counts for week/productId:" + ids[0],
          baseWeekUsers,
          (long) dashboardDto.getWeek().getAwsDeploymentsByProduct().get(ids[0]));
      assertEquals(
          "Compare deploy counts for month/productId:" + ids[0],
          baseMonthUsers,
          (long) dashboardDto.getMonth().getAwsDeploymentsByProduct().get(ids[0]));
      assertEquals(
          "Compare all time deploy counts for productId:" + ids[0],
          (long) allUsers.size(),
          (long) dashboardDto.getActiveAwsByProduct().get(ids[0]));
    }

    List<ProductCountDto> prodCountDtos = trialInstanceDao.countByCreatedAtAfter(yesterday);
    for (ProductCountDto count : prodCountDtos) {
      logger.info("prod-id:" + count.getProductId() + ",count:" + count.getCount());
    }

    int processed = 0;
    for (Long productId : validTrialProductIds) {
      assertEquals(
          "Compare counts for productId:" + productId,
          (long) allUsers.size(),
          (long) dashboardDto.getActiveInfor24ByProduct().get(productId));
      // SPECIFIC day/week/month checks for products
      assertEquals(
          "Compare trial counts for day/productId:"
              + productId
              + ",shortName:"
              + productDao.findById(productId).getShortName()
              + ",processed already:"
              + processed,
          (long) oneDayUserCount,
          (long) dashboardDto.getDay().getInfor24DeploymentsByProduct().get(productId));
      assertEquals(
          "Compare trial counts for week/productId:" + productId,
          baseWeekUsers,
          (long) dashboardDto.getWeek().getInfor24DeploymentsByProduct().get(productId));
      assertEquals(
          "Compare trial counts for month/productId:" + productId,
          baseMonthUsers,
          (long) dashboardDto.getMonth().getInfor24DeploymentsByProduct().get(productId));
      processed++;
    }

    assertEquals(
        "Compare users added since day",
        yesterdayOffset + oneDayUserCount,
        (long) dashboardDto.getDay().getNewUsersCount());
    assertEquals(
        "Compare users added since week",
        oneWeekOffset + baseWeekUsers,
        (long) dashboardDto.getWeek().getNewUsersCount());
    assertEquals(
        "Compare users added since day",
        oneMonthOffset + baseMonthUsers,
        (long) dashboardDto.getMonth().getNewUsersCount());
  }
 // =================
 private void activateDeploys(User user, List<Long[]> productList) {
   for (Long[] ids : productList) {
     Product product = productDao.findById(ids[0]);
     this.activateDeploy(user.getUsername(), product);
   }
 }
  @Test
  public void testGetRollingDeploys() throws Exception {
    int sixMonthDeploy = 2;
    int fiveMonthDeploy = 3;
    int fourMonthDeploy = 5;
    int threeMonthDeploy = 9;
    int twoMonthDeploy = 7;
    int oneMonthDeploy = 4;
    int totalDeploy =
        totalList(
            sixMonthDeploy,
            fiveMonthDeploy,
            fourMonthDeploy,
            threeMonthDeploy,
            twoMonthDeploy,
            oneMonthDeploy);
    int[] deployedCountList =
        new int[] {
          sixMonthDeploy,
          fiveMonthDeploy,
          fourMonthDeploy,
          threeMonthDeploy,
          twoMonthDeploy,
          oneMonthDeploy
        };
    int sixMonthTrial = 5;
    int fiveMonthTrial = 9;
    int fourMonthTrial = 4;
    int threeMonthTrial = 12;
    int twoMonthTrial = 1;
    int oneMonthTrial = 8;
    int totalTrial =
        totalList(
            sixMonthTrial,
            fiveMonthTrial,
            fourMonthTrial,
            threeMonthTrial,
            twoMonthTrial,
            oneMonthTrial);
    int[] trialCountList =
        new int[] {
          sixMonthTrial,
          fiveMonthTrial,
          fourMonthTrial,
          threeMonthTrial,
          twoMonthTrial,
          oneMonthTrial
        };

    assertEquals(
        "Lengths of trialMonths and deployMonths should be same",
        trialCountList.length,
        deployedCountList.length);

    User user =
        this.createUser("*****@*****.**", "UberUser", "LastName", "password", Role.ROLE_SALES);
    userDao.save(user);
    addAWSCredentials(user);
    user = userDao.findByUsername("*****@*****.**");
    assertNotNull(user);

    Date now = new Date();
    GregorianCalendar cal = new GregorianCalendar();
    cal.setTime(now);
    zeroOutTime(cal);
    cal.set(GregorianCalendar.DATE, 1);

    List<Date> datesToDeploy = getDates(cal.getTime(), oneMonthDeploy);
    List<Date> datesToTry = getDates(cal.getTime(), oneMonthTrial);

    cal.add(GregorianCalendar.MONTH, -1);
    datesToDeploy.addAll(getDates(cal.getTime(), twoMonthDeploy));
    datesToTry.addAll(getDates(cal.getTime(), twoMonthTrial));

    cal.add(GregorianCalendar.MONTH, -1);
    datesToDeploy.addAll(getDates(cal.getTime(), threeMonthDeploy));
    datesToTry.addAll(getDates(cal.getTime(), threeMonthTrial));

    cal.add(GregorianCalendar.MONTH, -1);
    datesToDeploy.addAll(getDates(cal.getTime(), fourMonthDeploy));
    datesToTry.addAll(getDates(cal.getTime(), fourMonthTrial));

    cal.add(GregorianCalendar.MONTH, -1);
    datesToDeploy.addAll(getDates(cal.getTime(), fiveMonthDeploy));
    datesToTry.addAll(getDates(cal.getTime(), fiveMonthTrial));

    cal.add(GregorianCalendar.MONTH, -1);
    datesToDeploy.addAll(getDates(cal.getTime(), sixMonthDeploy));
    datesToTry.addAll(getDates(cal.getTime(), sixMonthTrial));

    assertEquals("Trial total dates", totalTrial, datesToTry.size());
    assertEquals("Deploy total dates", totalDeploy, datesToDeploy.size());

    Region region = regionDao.findById(1L);
    assertNotNull(region);
    /*
     * TRIALS SECTION
     */

    List<Product> productsForTrial = productDao.findByTrialsAvailable(true);
    ArrayList<Long> validTrialProductIds = new ArrayList<>();

    for (Product product : productsForTrial) {

      ProductVersion productVersion = pickOne(product.getProductVersions(), region, false);

      if (productVersion == null) {
        continue;
      }
      loginAdminUser();
      this.activateTrial("*****@*****.**", product);
      validTrialProductIds.add(product.getId());
      login("*****@*****.**", "password");

      for (Date tryDate : datesToTry) {
        DeployRequestDto deployRequestDto =
            this.getTrialRequestFor(user, productVersion, region, tryDate);
        DeploymentStackDto retDto =
            deploymentService.deployMultipleProducts(getRequestStub(), deployRequestDto);
        TrialInstance instance = trialInstanceDao.findById(retDto.getId());
        assertEquals(instance.getCreatedAt(), tryDate);
      }
    }

    List<Long[]> productAndVersionIdList =
        this.getDtoProdAndVersionList(productDao.findAll(), region);
    for (Date deployDate : datesToDeploy) {
      AmazonCredentials amazonCredentials =
          amazonCredentialsDao.findByUserAndName(user, "Dummy Key");
      assertNotNull(amazonCredentials);
      loginAdminUser();
      activateDeploys(user, productAndVersionIdList);
      login(user.getUsername(), "password");
      DeployRequestDto reqDto =
          this.getDeployRequestFor(
              user, productAndVersionIdList, region, amazonCredentials, deployDate);
      DeploymentStackDto result =
          deploymentService.deployMultipleProducts(getRequestStub(), reqDto);
      DeploymentStack stack = deploymentStackDao.findById(result.getId());
      assertEquals(
          "deployDate and stack created at times should be ==", deployDate, stack.getCreatedAt());
    }

    loginAdminUser();
    DashboardRollingDto rollingDto = dashboardService.getRollingList(deployedCountList.length);
    assertEquals(
        "Confirm correct num of months..",
        deployedCountList.length,
        (int) rollingDto.getMonthCount());
    int index = 0;
    for (DashboardRollingPeriodDto period : rollingDto.getRollingDeployments()) {
      DashboardRollingMonthDto month = (DashboardRollingMonthDto) period;
      assertEquals("Confirm index position", index + 1, (int) month.getMonth());
      assertEquals(
          "Confirm total deploys for month (index:" + index + "):" + month.getName(),
          (long) deployedCountList[index],
          (long) month.getAws());
      assertEquals(
          "Confirm total trials for month (index:" + index + "):" + month.getName(),
          (long) (trialCountList[index] * validTrialProductIds.size()),
          (long) month.getInfor24());

      index++;
    }
  }