services/self-service/src/test/java/com/epam/dlab/backendapi/service/impl/LibraryServiceImplTest.java

/*
 * 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 com.epam.dlab.backendapi.service.impl;

import com.epam.dlab.auth.UserInfo;
import com.epam.dlab.backendapi.dao.ExploratoryDAO;
import com.epam.dlab.backendapi.dao.ExploratoryLibDAO;
import com.epam.dlab.backendapi.domain.EndpointDTO;
import com.epam.dlab.backendapi.domain.RequestId;
import com.epam.dlab.backendapi.resources.dto.LibInfoRecord;
import com.epam.dlab.backendapi.resources.dto.LibInstallFormDTO;
import com.epam.dlab.backendapi.resources.dto.LibKey;
import com.epam.dlab.backendapi.resources.dto.LibraryStatus;
import com.epam.dlab.backendapi.service.EndpointService;
import com.epam.dlab.backendapi.util.RequestBuilder;
import com.epam.dlab.cloud.CloudProvider;
import com.epam.dlab.dto.UserInstanceDTO;
import com.epam.dlab.dto.computational.UserComputationalResource;
import com.epam.dlab.dto.exploratory.LibInstallDTO;
import com.epam.dlab.dto.exploratory.LibStatus;
import com.epam.dlab.dto.exploratory.LibraryInstallDTO;
import com.epam.dlab.exceptions.DlabException;
import com.epam.dlab.model.library.Library;
import com.epam.dlab.rest.client.RESTService;
import org.bson.Document;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.anyListOf;
import static org.mockito.Mockito.anyString;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.refEq;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class LibraryServiceImplTest {

    private static final String LIB_NAME = "name";
    private static final String LIB_GROUP = "group";
    private static final String LIB_VERSION = "version";
    private static final String UUID = "id";
    private final String USER = "test";
    private final String EXPLORATORY_NAME = "explName";
    private final String PROJECT = "projectName";
    private final String COMPUTATIONAL_NAME = "compName";

    private LibInstallDTO liDto;
    private List<LibInstallDTO> libs;
    private LibInstallFormDTO libInstallFormDTO;
    private LibraryInstallDTO libraryInstallDto;

    @Mock
    private ExploratoryDAO exploratoryDAO;
    @Mock
    private ExploratoryLibDAO libraryDAO;
    @Mock
    private RequestBuilder requestBuilder;
    @Mock
    private RequestId requestId;
    @Mock
    private RESTService provisioningService;
    @Mock
    private EndpointService endpointService;

    @Rule
	public ExpectedException expectedException = ExpectedException.none();

	@InjectMocks
	private LibraryServiceImpl libraryService;

	@Before
	public void setUp() {
		prepareForTesting();
	}

	@Test
	public void testGetLibs() {
        Document document = new Document();
        when(libraryDAO.findExploratoryLibraries(anyString(), anyString(), anyString())).thenReturn(document);

        List<Document> expectedList = new ArrayList<>();
        List<Document> actualList = libraryService.getLibs(USER, PROJECT, EXPLORATORY_NAME, "");
        assertNotNull(actualList);
        assertEquals(expectedList, actualList);

        verify(libraryDAO).findExploratoryLibraries(USER, PROJECT, EXPLORATORY_NAME);
        verifyNoMoreInteractions(libraryDAO);
    }

	@Test
	public void getLibInfo() {
        Document document = new Document();
        when(libraryDAO.findAllLibraries(anyString(), anyString(), anyString())).thenReturn(document);

        List<LibInfoRecord> expectedList = new ArrayList<>();
        List<LibInfoRecord> actualList = libraryService.getLibInfo(USER, PROJECT, EXPLORATORY_NAME);
        assertNotNull(actualList);
        assertEquals(expectedList, actualList);

        verify(libraryDAO).findAllLibraries(USER, PROJECT, EXPLORATORY_NAME);
        verifyNoMoreInteractions(libraryDAO);
    }

	@Test
	public void getLibInfoWhenListsOfExploratoryAndComputationalLibsAreNotEmpty() {
        when(libraryDAO.findAllLibraries(anyString(), anyString(), anyString()))
                .thenReturn(getDocumentWithExploratoryAndComputationalLibs());

        List<LibInfoRecord> expectedList = getLibInfoRecordList();
        List<LibInfoRecord> actualList = libraryService.getLibInfo(USER, PROJECT, EXPLORATORY_NAME);
        assertNotNull(actualList);
        assertEquals(expectedList, actualList);

        verify(libraryDAO).findAllLibraries(USER, PROJECT, EXPLORATORY_NAME);
        verifyNoMoreInteractions(libraryDAO);
    }

	@Test
	public void installComputationalLibsWithoutOverride() {
        final LibraryInstallDTO libraryInstallDTO = new LibraryInstallDTO();
        final List<LibInstallDTO> libsToInstall = getLibs("installing");
        libraryInstallDTO.setLibs(libsToInstall);
        final UserInfo user = getUser();

        when(endpointService.get(anyString())).thenReturn(endpointDTO());
        when(exploratoryDAO.fetchExploratoryFields(anyString(), anyString(), anyString(), anyString())).thenReturn(getUserInstanceDto());
        when(provisioningService.post(anyString(), anyString(), any(LibraryInstallDTO.class), any())).thenReturn(UUID);
        when(requestBuilder.newLibInstall(any(UserInfo.class), any(UserInstanceDTO.class),
                any(UserComputationalResource.class), anyListOf(LibInstallDTO.class), any(EndpointDTO.class))).thenReturn(libraryInstallDTO);


        final String uuid = libraryService.installComputationalLibs(user, PROJECT, EXPLORATORY_NAME,
                COMPUTATIONAL_NAME, getLibs(null));

        assertEquals(UUID, uuid);

        verify(libraryDAO).getLibrary(USER, PROJECT, EXPLORATORY_NAME, COMPUTATIONAL_NAME, LIB_GROUP, LIB_NAME);
        verify(requestBuilder).newLibInstall(refEq(user), refEq(getUserInstanceDto()),
                refEq(getUserComputationalResourceWithName(COMPUTATIONAL_NAME)), eq(libsToInstall), refEq(endpointDTO()));
        verify(provisioningService).post(eq(endpointDTO().getUrl() + "library/computational/lib_install"), eq(user.getAccessToken()),
                refEq(libraryInstallDTO), eq(String.class));
        verify(libraryDAO).addLibrary(eq(USER), eq(PROJECT), eq(EXPLORATORY_NAME),
                eq(COMPUTATIONAL_NAME), refEq(libsToInstall.get(0)), eq(false));
        verify(requestId).put(user.getName(), UUID);
        verify(exploratoryDAO).fetchExploratoryFields(USER, PROJECT, EXPLORATORY_NAME, COMPUTATIONAL_NAME);
        verifyNoMoreInteractions(libraryDAO, requestBuilder, provisioningService, requestId, exploratoryDAO);
    }

	@Test
	public void installComputationalLibsWhenComputationalNotFound() {
        final LibraryInstallDTO libraryInstallDTO = new LibraryInstallDTO();
        final List<LibInstallDTO> libsToInstall = getLibs("installing");
        libraryInstallDTO.setLibs(libsToInstall);
        libraryInstallDTO.setProject(PROJECT);
        final UserInfo user = getUser();

        when(endpointService.get(anyString())).thenReturn(endpointDTO());
        when(exploratoryDAO.fetchExploratoryFields(anyString(), anyString(), anyString(), anyString())).thenReturn(getUserInstanceDto());
        when(provisioningService.post(anyString(), anyString(), any(LibraryInstallDTO.class), any())).thenReturn(UUID);
        when(requestBuilder.newLibInstall(any(UserInfo.class), any(UserInstanceDTO.class),
                any(UserComputationalResource.class), anyListOf(LibInstallDTO.class), any(EndpointDTO.class)))
                .thenReturn(libraryInstallDTO);


        expectedException.expect(DlabException.class);
        expectedException.expectMessage("Computational with name " + COMPUTATIONAL_NAME + "X was not found");

        libraryService.installComputationalLibs(user, PROJECT, EXPLORATORY_NAME,
                COMPUTATIONAL_NAME + "X", getLibs(null));
    }

	@Test
	public void installComputationalLibsWithOverride() {
        final LibraryInstallDTO libraryInstallDTO = new LibraryInstallDTO();
        final List<LibInstallDTO> libsToInstall = getLibs("installing");
        libraryInstallDTO.setProject(PROJECT);
        libraryInstallDTO.setLibs(libsToInstall);
        final UserInfo user = getUser();

        when(endpointService.get(anyString())).thenReturn(endpointDTO());
        when(exploratoryDAO.fetchExploratoryFields(anyString(), anyString(), anyString(), anyString())).thenReturn(getUserInstanceDto());
        when(provisioningService.post(anyString(), anyString(), any(LibraryInstallDTO.class), any())).thenReturn(UUID);
        when(requestBuilder.newLibInstall(any(UserInfo.class), any(UserInstanceDTO.class),
                any(UserComputationalResource.class), anyListOf(LibInstallDTO.class), any(EndpointDTO.class)))
                .thenReturn(libraryInstallDTO);
        when(libraryDAO.getLibrary(anyString(), anyString(), anyString(), anyString(), anyString(), anyString())).thenReturn(getLibrary(LibStatus.INSTALLED));

        final String uuid = libraryService.installComputationalLibs(user, PROJECT, EXPLORATORY_NAME,
                COMPUTATIONAL_NAME, getLibs(null));

        assertEquals(UUID, uuid);

        libsToInstall.get(0).setOverride(true);
        verify(exploratoryDAO).fetchExploratoryFields(USER, PROJECT, EXPLORATORY_NAME, COMPUTATIONAL_NAME);
        verify(libraryDAO).getLibrary(USER, PROJECT, EXPLORATORY_NAME, COMPUTATIONAL_NAME, LIB_GROUP, LIB_NAME);
        verify(libraryDAO).addLibrary(eq(USER), eq(PROJECT), eq(EXPLORATORY_NAME),
                eq(COMPUTATIONAL_NAME), refEq(libsToInstall.get(0)), eq(true));
        verify(requestBuilder).newLibInstall(refEq(user), refEq(getUserInstanceDto()),
                refEq(getUserComputationalResourceWithName(COMPUTATIONAL_NAME)), eq(libsToInstall), refEq(endpointDTO()));
        verify(provisioningService).post(eq(endpointDTO().getUrl() + "library/computational/lib_install"),
                eq(user.getAccessToken()),
                refEq(libraryInstallDTO), eq(String.class));
        verify(requestId).put(user.getName(), UUID);
        verifyNoMoreInteractions(libraryDAO, requestBuilder, provisioningService, requestId, exploratoryDAO);

    }


	@Test
	public void installComputationalLibsWhenLibraryIsAlreadyInstalling() {
        final LibraryInstallDTO libraryInstallDTO = new LibraryInstallDTO();
        final List<LibInstallDTO> libsToInstall = getLibs("installing");
        libraryInstallDTO.setLibs(libsToInstall);
        final UserInfo user = getUser();

        when(endpointService.get(anyString())).thenReturn(endpointDTO());
        when(exploratoryDAO.fetchExploratoryFields(anyString(), anyString(), anyString(), anyString())).thenReturn(getUserInstanceDto());
        when(provisioningService.post(anyString(), anyString(), any(LibraryInstallDTO.class), any())).thenReturn(UUID);
        when(requestBuilder.newLibInstall(any(UserInfo.class), any(UserInstanceDTO.class),
                any(UserComputationalResource.class), anyListOf(LibInstallDTO.class), any(EndpointDTO.class)))
                .thenReturn(libraryInstallDTO);
        when(libraryDAO.getLibrary(anyString(), anyString(), anyString(), anyString(), anyString(), anyString())).thenReturn(getLibrary(LibStatus.INSTALLING));

        try {
            libraryService.installComputationalLibs(user, PROJECT, EXPLORATORY_NAME,
                    COMPUTATIONAL_NAME, getLibs(null));
        } catch (DlabException e) {
            assertEquals("Library name is already installing", e.getMessage());
        }
        verify(exploratoryDAO).fetchExploratoryFields(USER, PROJECT, EXPLORATORY_NAME, COMPUTATIONAL_NAME);
        verify(libraryDAO).getLibrary(USER, PROJECT, EXPLORATORY_NAME, COMPUTATIONAL_NAME, LIB_GROUP, LIB_NAME);
        verifyNoMoreInteractions(libraryDAO, requestBuilder, provisioningService, requestId, exploratoryDAO);
    }

	@Test
	public void installExploratoryLibsWithoutOverride() {
        final LibraryInstallDTO libraryInstallDTO = new LibraryInstallDTO();
        final List<LibInstallDTO> libsToInstall = getLibs("installing");
        libraryInstallDTO.setLibs(libsToInstall);
        final UserInfo user = getUser();

        when(endpointService.get(anyString())).thenReturn(endpointDTO());
        when(exploratoryDAO.fetchRunningExploratoryFields(anyString(), anyString(), anyString())).thenReturn(getUserInstanceDto());
        when(provisioningService.post(anyString(), anyString(), any(LibraryInstallDTO.class), any())).thenReturn(UUID);
        when(requestBuilder.newLibInstall(any(UserInfo.class), any(UserInstanceDTO.class), any(EndpointDTO.class),
                anyListOf(LibInstallDTO.class))).thenReturn(libraryInstallDTO);


        final String uuid = libraryService.installExploratoryLibs(user, PROJECT, EXPLORATORY_NAME, getLibs(null));

        assertEquals(UUID, uuid);

        verify(libraryDAO).getLibrary(USER, PROJECT, EXPLORATORY_NAME, LIB_GROUP, LIB_NAME);
        verify(requestBuilder).newLibInstall(refEq(user), refEq(getUserInstanceDto()), eq(endpointDTO()), eq(libsToInstall));
        verify(provisioningService).post(eq(endpointDTO().getUrl() + "library/exploratory/lib_install"), eq(user.getAccessToken()),
                refEq(libraryInstallDTO), eq(String.class));
        verify(libraryDAO).addLibrary(eq(USER), eq(PROJECT), eq(EXPLORATORY_NAME), refEq(libsToInstall.get(0)), eq(false));
        verify(requestId).put(user.getName(), UUID);
        verify(exploratoryDAO).fetchRunningExploratoryFields(USER, PROJECT, EXPLORATORY_NAME);
        verifyNoMoreInteractions(libraryDAO, requestBuilder, provisioningService, requestId, exploratoryDAO);
    }

	@Test
	public void installExploratoryLibsWithOverride() {
        final LibraryInstallDTO libraryInstallDTO = new LibraryInstallDTO();
        final List<LibInstallDTO> libsToInstall = getLibs("installing");
        libraryInstallDTO.setLibs(libsToInstall);
        final UserInfo user = getUser();

        when(endpointService.get(anyString())).thenReturn(endpointDTO());
        when(exploratoryDAO.fetchRunningExploratoryFields(anyString(), anyString(), anyString())).thenReturn(getUserInstanceDto());
        when(provisioningService.post(anyString(), anyString(), any(LibraryInstallDTO.class), any())).thenReturn(UUID);
        when(requestBuilder.newLibInstall(any(UserInfo.class), any(UserInstanceDTO.class), any(EndpointDTO.class),
                anyListOf(LibInstallDTO.class))).thenReturn(libraryInstallDTO);
        when(libraryDAO.getLibrary(anyString(), anyString(), anyString(), anyString(), anyString())).thenReturn(getLibrary(LibStatus.INSTALLED));

        final String uuid = libraryService.installExploratoryLibs(user, PROJECT, EXPLORATORY_NAME, getLibs(null));

        assertEquals(UUID, uuid);

        libsToInstall.get(0).setOverride(true);
        verify(libraryDAO).getLibrary(USER, PROJECT, EXPLORATORY_NAME, LIB_GROUP, LIB_NAME);
        verify(libraryDAO).addLibrary(eq(USER), eq(PROJECT), eq(EXPLORATORY_NAME), refEq(libsToInstall.get(0)), eq(true));
        verify(requestBuilder).newLibInstall(refEq(user), refEq(getUserInstanceDto()), eq(endpointDTO()), eq(libsToInstall));
        verify(exploratoryDAO).fetchRunningExploratoryFields(USER, PROJECT, EXPLORATORY_NAME);
        verify(provisioningService).post(eq(endpointDTO().getUrl() + "library/exploratory/lib_install"), eq(user.getAccessToken()),
                refEq(libraryInstallDTO), eq(String.class));
        verify(requestId).put(USER, uuid);
        verifyNoMoreInteractions(libraryDAO, requestBuilder, provisioningService, requestId, exploratoryDAO);
    }

	@Test
	public void installExploratoryLibsWhenLibIsAlreadyInstalling() {
        final LibraryInstallDTO libraryInstallDTO = new LibraryInstallDTO();
        final List<LibInstallDTO> libsToInstall = getLibs("installing");
        libraryInstallDTO.setLibs(libsToInstall);
        final UserInfo user = getUser();

        when(endpointService.get(anyString())).thenReturn(endpointDTO());
        when(exploratoryDAO.fetchRunningExploratoryFields(anyString(), anyString(), anyString())).thenReturn(getUserInstanceDto());
        when(provisioningService.post(anyString(), anyString(), any(LibraryInstallDTO.class), any())).thenReturn(UUID);
        when(requestBuilder.newLibInstall(any(UserInfo.class), any(UserInstanceDTO.class), any(EndpointDTO.class),
                anyListOf(LibInstallDTO.class))).thenReturn(libraryInstallDTO);
        when(libraryDAO.getLibrary(anyString(), anyString(), anyString(), anyString(), anyString())).thenReturn(getLibrary(LibStatus.INSTALLING));

        try {
            libraryService.installExploratoryLibs(user, PROJECT, EXPLORATORY_NAME, getLibs(null));
        } catch (DlabException e) {
            assertEquals("Library name is already installing", e.getMessage());
        }

        verify(libraryDAO).getLibrary(USER, PROJECT, EXPLORATORY_NAME, LIB_GROUP, LIB_NAME);
        verify(exploratoryDAO).fetchRunningExploratoryFields(USER, PROJECT, EXPLORATORY_NAME);
        verifyNoMoreInteractions(libraryDAO, requestBuilder, provisioningService, requestId, exploratoryDAO);

    }

	private Library getLibrary(LibStatus status) {
		return new Library(LIB_GROUP, LIB_NAME, "1", status, "");
	}

	private List<LibInstallDTO> getLibs(String status) {
		final LibInstallDTO libInstallDTO = new LibInstallDTO(LIB_GROUP, LIB_NAME, LIB_VERSION);
		libInstallDTO.setStatus(status);
		return Collections.singletonList(libInstallDTO);
	}

	private UserInfo getUser() {
		return new UserInfo(USER, "token123");
	}

	private void prepareForTesting() {
		liDto = new LibInstallDTO("someGroup", "someName", "someVersion");
		libs = Collections.singletonList(liDto);
		libInstallFormDTO = new LibInstallFormDTO();
		libInstallFormDTO.setNotebookName(EXPLORATORY_NAME);
		libInstallFormDTO.setComputationalName(COMPUTATIONAL_NAME);
		libInstallFormDTO.setLibs(libs);
		libraryInstallDto = new LibraryInstallDTO().withExploratoryName(EXPLORATORY_NAME)
				.withComputationalName(COMPUTATIONAL_NAME).withApplicationName("");
		libraryInstallDto.setLibs(new ArrayList<>());
	}

	private UserComputationalResource getUserComputationalResourceWithName(String name) {
		UserComputationalResource resource = new UserComputationalResource();
		resource.setComputationalName(name);
		resource.setComputationalId("someId");
		resource.setImageName("someImageName");
		return resource;
	}

	private UserInstanceDTO getUserInstanceDto() {
		final UserInstanceDTO userInstanceDTO =
				new UserInstanceDTO().withUser(USER).withExploratoryName(EXPLORATORY_NAME);
		userInstanceDTO.getResources().add(getUserComputationalResourceWithName(COMPUTATIONAL_NAME));
		return userInstanceDTO;
	}

	private List<Document> getExpLibsList() {
		Document explLibsDoc = new Document();
		explLibsDoc.append(ExploratoryLibDAO.LIB_NAME, "expLibName");
		explLibsDoc.append(ExploratoryLibDAO.LIB_VERSION, "expLibVersion");
		explLibsDoc.append(ExploratoryLibDAO.LIB_GROUP, "expLibGroup");
		explLibsDoc.append(ExploratoryLibDAO.STATUS, "expLibStatus");
		explLibsDoc.append(ExploratoryLibDAO.ERROR_MESSAGE, "expLibErrorMessage");
		return Collections.singletonList(explLibsDoc);
	}

	private Document getCompLibs() {
		Document compLibs = new Document();
		compLibs.append(ExploratoryLibDAO.LIB_NAME, "compLibName");
		compLibs.append(ExploratoryLibDAO.LIB_VERSION, "compLibVersion");
		compLibs.append(ExploratoryLibDAO.LIB_GROUP, "compLibGroup");
		compLibs.append(ExploratoryLibDAO.STATUS, "compLibStatus");
		compLibs.append(ExploratoryLibDAO.ERROR_MESSAGE, "compLibErrorMessage");

		Document compResourcesAndLibs = new Document();
		compResourcesAndLibs.append("compName", Collections.singletonList(compLibs));
		return compResourcesAndLibs;
	}

	private Document getDocumentWithExploratoryAndComputationalLibs() {
		return new Document().append(ExploratoryLibDAO.EXPLORATORY_LIBS, getExpLibsList())
				.append(ExploratoryLibDAO.COMPUTATIONAL_LIBS, getCompLibs());
	}

	private List<LibInfoRecord> getLibInfoRecordList() {
		LibKey explLibKey = new LibKey("expLibName", "expLibVersion", "expLibGroup");
		List<LibraryStatus> explLibStatuses = Collections.singletonList(
				new LibraryStatus(EXPLORATORY_NAME, "notebook", "expLibStatus", "expLibErrorMessage"));

		LibKey compLibKey = new LibKey("compLibName", "compLibVersion", "compLibGroup");
		List<LibraryStatus> compLibStatuses = Collections.singletonList(
				new LibraryStatus("compName", "cluster", "compLibStatus", "compLibErrorMessage"));

		return Arrays.asList(
				new LibInfoRecord(compLibKey, compLibStatuses),
				new LibInfoRecord(explLibKey, explLibStatuses)
		);
	}

	private EndpointDTO endpointDTO() {
		return new EndpointDTO("test", "url", "", null, EndpointDTO.EndpointStatus.ACTIVE, CloudProvider.AWS);
	}

}