AbstractServiceImplTest.java

/*
 * Copyright 2014-2016 CyberVision, Inc.
 *
 * Licensed 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.kaaproject.kaa.server.common.dao.service;

import static org.apache.commons.lang.StringUtils.isBlank;

import org.junit.Assert;
import org.kaaproject.kaa.common.dto.ApplicationDto;
import org.kaaproject.kaa.common.dto.EndpointGroupDto;
import org.kaaproject.kaa.common.dto.EndpointProfileSchemaDto;
import org.kaaproject.kaa.common.dto.KaaAuthorityDto;
import org.kaaproject.kaa.common.dto.TenantDto;
import org.kaaproject.kaa.common.dto.UserDto;
import org.kaaproject.kaa.common.dto.ctl.CTLSchemaDto;
import org.kaaproject.kaa.common.dto.ctl.CtlSchemaMetaInfoDto;
import org.kaaproject.kaa.server.common.dao.ApplicationService;
import org.kaaproject.kaa.server.common.dao.CtlService;
import org.kaaproject.kaa.server.common.dao.ConfigurationService;
import org.kaaproject.kaa.server.common.dao.EndpointService;
import org.kaaproject.kaa.server.common.dao.ProfileService;
import org.kaaproject.kaa.server.common.dao.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.UUID;

public abstract class AbstractServiceImplTest {

  protected static final String APPLICATION_NAME = "Generated Test Application";
  protected static final String TENANT_NAME = "Generated Test Tenant";
  protected static final String USER_NAME = "Generated Test Username";
  protected static final String DEFAULT_FQN = "org.kaaproject.kaa.ctl.TestSchema";
  protected static final Random random = new Random(0);
  private final Logger LOG = LoggerFactory.getLogger(getClass());
  @Autowired
  protected UserService userService;
  @Autowired
  protected ConfigurationService configurationService;
  @Autowired
  protected ApplicationService applicationService;
  @Autowired
  protected CtlService ctlService;
  @Autowired
  protected ProfileService profileService;
  @Autowired
  protected EndpointService endpointService;

  protected TenantDto generateTenant() {
    TenantDto tenant = new TenantDto();
    tenant.setName(TENANT_NAME);
    tenant = userService.saveTenant(tenant);
    return tenant;
  }

  protected ApplicationDto generateApplication(String tenantId) {
    ApplicationDto application = new ApplicationDto();
    if (isBlank(tenantId)) {
      application.setTenantId(generateTenant().getId());
    } else {
      application.setTenantId(tenantId);
    }
    application.setName(APPLICATION_NAME);
    return applicationService.saveApp(application);
  }

  protected List<UserDto> generateUsers(String tenantId, KaaAuthorityDto authority, int count) {
    List<UserDto> users = new ArrayList<>(count);
    UserDto userDto;
    for (int i = 0; i < count; i++) {
      userDto = new UserDto();
      userDto.setUsername(USER_NAME);
      userDto.setTenantId(tenantId);
      userDto.setExternalUid(UUID.randomUUID().toString());
      userDto.setAuthority(authority);
      userDto = userService.saveUser(userDto);
      users.add(userDto);
    }
    return users;
  }


  protected String readSchemaFileAsString(String filePath) throws IOException {
    try {
      Path path = Paths.get(Thread.currentThread().getContextClassLoader().getResource(filePath).toURI());
      byte[] bytes = Files.readAllBytes(path);
      return new String(bytes);
    } catch (URISyntaxException e) {
      LOG.error("Can't generate configs {}", e);
    }
    return null;
  }

  protected CTLSchemaDto generateCTLSchemaDto(String fqn, String tenantId, int version) {
    CTLSchemaDto ctlSchema = new CTLSchemaDto();
    CtlSchemaMetaInfoDto metaInfoDto = new CtlSchemaMetaInfoDto(fqn, tenantId);
    ctlSchema.setMetaInfo(metaInfoDto);
    ctlSchema.setVersion(version);
    ctlSchema.setBody(UUID.randomUUID().toString());
    return ctlSchema;
  }

  protected List<EndpointProfileSchemaDto> generateProfSchema(String tenantId, String applicationId, int count) {
    List<EndpointProfileSchemaDto> schemas = Collections.emptyList();
    try {
      if (isBlank(tenantId)) {
        tenantId = generateTenant().getId();
      }
      if (isBlank(applicationId)) {
        applicationId = generateApplication(tenantId).getId();
      }
      CTLSchemaDto ctlSchemaDto = ctlService.saveCtlSchema(generateCTLSchemaDto(DEFAULT_FQN, tenantId, 1));
      EndpointProfileSchemaDto schemaDto;
      schemas = new ArrayList<>(count);
      for (int i = 0; i < count; i++) {
        schemaDto = new EndpointProfileSchemaDto();
        schemaDto.setApplicationId(applicationId);
        schemaDto.setCtlSchemaId(ctlSchemaDto.getId());
        schemaDto.setCreatedUsername("Test User");
        schemaDto.setName("Test Name");
        schemaDto = profileService.saveProfileSchema(schemaDto);
        Assert.assertNotNull(schemaDto);
        schemas.add(schemaDto);
      }
    } catch (Exception e) {
      LOG.error("Can't generate profile schemas {}", e);
      Assert.fail("Can't generate profile schemas.");
    }
    return schemas;
  }

  protected EndpointGroupDto generateEndpointGroup(String applicationId) {
    return generateEndpointGroup(applicationId, "GROUP_ALL");
  }

  protected EndpointGroupDto generateEndpointGroup(String applicationId, String endpointGroupName) {
    EndpointGroupDto group = new EndpointGroupDto();
    if (isBlank(applicationId)) {
      applicationId = generateApplication(null).getId();
    }
    group.setApplicationId(applicationId);
    group.setName(endpointGroupName);
    group.setWeight(random.nextInt());
    return endpointService.saveEndpointGroup(group);
  }
}