// 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.cloudstack.acl;

import java.util.ArrayList;
import java.util.List;

import org.apache.cloudstack.acl.dao.RoleDao;
import org.apache.commons.collections.CollectionUtils;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.runners.MockitoJUnitRunner;

import com.cloud.user.Account;
import com.cloud.user.AccountManager;

@RunWith(MockitoJUnitRunner.class)
public class RoleManagerImplTest {

    @Spy
    @InjectMocks
    private RoleManagerImpl roleManagerImpl;
    @Mock
    private AccountManager accountManagerMock;
    @Mock
    private RoleDao roleDaoMock;

    @Mock
    private Account accountMock;
    private long accountMockId = 100l;

    @Mock
    private RoleVO roleVoMock;
    private long roleMockId = 1l;

    @Before
    public void beforeTest() {
        Mockito.doReturn(accountMockId).when(accountMock).getId();
        Mockito.doReturn(accountMock).when(roleManagerImpl).getCurrentAccount();

        Mockito.doReturn(roleMockId).when(roleVoMock).getId();
    }

    @Test
    public void findRoleTestIdNull() {
        Role returnedRole = roleManagerImpl.findRole(null);
        Assert.assertNull(returnedRole);
    }

    @Test
    public void findRoleTestIdZero() {
        Role returnedRole = roleManagerImpl.findRole(0l);
        Assert.assertNull(returnedRole);
    }

    @Test
    public void findRoleTestIdNegative() {
        Role returnedRole = roleManagerImpl.findRole(-1l);
        Assert.assertNull(returnedRole);
    }

    @Test
    public void findRoleTestRoleNotFound() {
        Mockito.doReturn(null).when(roleDaoMock).findById(roleMockId);
        Role returnedRole = roleManagerImpl.findRole(roleMockId);
        Assert.assertNull(returnedRole);
    }

    @Test
    public void findRoleTestNotRootAdminAndNotRoleAdminType() {
        Mockito.doReturn(RoleType.DomainAdmin).when(roleVoMock).getRoleType();
        Mockito.doReturn(roleVoMock).when(roleDaoMock).findById(roleMockId);
        Mockito.doReturn(false).when(accountManagerMock).isRootAdmin(accountMockId);

        Role returnedRole = roleManagerImpl.findRole(roleMockId);

        Assert.assertEquals(roleMockId, returnedRole.getId());
        Mockito.verify(accountManagerMock).isRootAdmin(accountMockId);
        Mockito.verify(roleVoMock, Mockito.times(1)).getRoleType();
    }

    @Test
    public void findRoleTestRootAdminAndNotRoleAdminType() {
        Mockito.doReturn(RoleType.DomainAdmin).when(roleVoMock).getRoleType();
        Mockito.doReturn(roleVoMock).when(roleDaoMock).findById(roleMockId);
        Mockito.doReturn(true).when(accountManagerMock).isRootAdmin(accountMockId);

        Role returnedRole = roleManagerImpl.findRole(roleMockId);

        Assert.assertEquals(roleMockId, returnedRole.getId());
        Mockito.verify(accountManagerMock).isRootAdmin(accountMockId);
        Mockito.verify(roleVoMock, Mockito.times(0)).getRoleType();
    }

    @Test
    public void findRoleTestRootAdminAndRoleAdminType() {
        Mockito.doReturn(RoleType.Admin).when(roleVoMock).getRoleType();
        Mockito.doReturn(roleVoMock).when(roleDaoMock).findById(roleMockId);
        Mockito.doReturn(true).when(accountManagerMock).isRootAdmin(accountMockId);

        Role returnedRole = roleManagerImpl.findRole(roleMockId);

        Assert.assertEquals(roleMockId, returnedRole.getId());
        Mockito.verify(accountManagerMock).isRootAdmin(accountMockId);
        Mockito.verify(roleVoMock, Mockito.times(0)).getRoleType();
    }

    @Test
    public void findRoleTestNotRootAdminAndRoleAdminType() {
        Mockito.doReturn(RoleType.Admin).when(roleVoMock).getRoleType();
        Mockito.doReturn(roleVoMock).when(roleDaoMock).findById(roleMockId);
        Mockito.doReturn(false).when(accountManagerMock).isRootAdmin(accountMockId);

        Role returnedRole = roleManagerImpl.findRole(roleMockId);

        Assert.assertNull(returnedRole);
        Mockito.verify(accountManagerMock).isRootAdmin(accountMockId);
        Mockito.verify(roleVoMock, Mockito.times(1)).getRoleType();
    }

    @Test
    public void findRolesByNameTestNullRoleName() {
        List<Role> rolesFound = roleManagerImpl.findRolesByName(null);

        Assert.assertTrue(CollectionUtils.isEmpty(rolesFound));
    }

    @Test
    public void findRolesByNameTestEmptyRoleName() {
        List<Role> rolesFound = roleManagerImpl.findRolesByName("");

        Assert.assertTrue(CollectionUtils.isEmpty(rolesFound));
    }

    @Test
    public void findRolesByNameTestBlankRoleName() {
        List<Role> rolesFound = roleManagerImpl.findRolesByName("      ");

        Assert.assertTrue(CollectionUtils.isEmpty(rolesFound));
    }

    @Test
    public void findRolesByNameTest() {
        String roleName = "roleName";
        ArrayList<Role> toBeReturned = new ArrayList<>();
        Mockito.doReturn(toBeReturned).when(roleDaoMock).findAllByName(roleName);

        roleManagerImpl.findRolesByName(roleName);

        Mockito.verify(roleManagerImpl).removeRootAdminRolesIfNeeded(toBeReturned);
    }

    @Test
    public void removeRootAdminRolesIfNeededTestRootAdmin() {
        Mockito.doReturn(accountMock).when(roleManagerImpl).getCurrentAccount();
        Mockito.doReturn(true).when(accountManagerMock).isRootAdmin(accountMockId);

        List<Role> roles = new ArrayList<>();
        roleManagerImpl.removeRootAdminRolesIfNeeded(roles);

        Mockito.verify(roleManagerImpl, Mockito.times(0)).removeRootAdminRoles(roles);
    }

    @Test
    public void removeRootAdminRolesIfNeededTestNonRootAdminUser() {
        Mockito.doReturn(accountMock).when(roleManagerImpl).getCurrentAccount();
        Mockito.doReturn(false).when(accountManagerMock).isRootAdmin(accountMockId);

        List<Role> roles = new ArrayList<>();
        roleManagerImpl.removeRootAdminRolesIfNeeded(roles);

        Mockito.verify(roleManagerImpl, Mockito.times(1)).removeRootAdminRoles(roles);
    }

    @Test
    public void removeRootAdminRolesTest() {
        List<Role> roles = new ArrayList<>();
        Role roleRootAdmin = Mockito.mock(Role.class);
        Mockito.doReturn(RoleType.Admin).when(roleRootAdmin).getRoleType();

        Role roleDomainAdmin = Mockito.mock(Role.class);
        Mockito.doReturn(RoleType.DomainAdmin).when(roleDomainAdmin).getRoleType();

        Role roleResourceAdmin = Mockito.mock(Role.class);
        Mockito.doReturn(RoleType.ResourceAdmin).when(roleResourceAdmin).getRoleType();

        Role roleUser = Mockito.mock(Role.class);
        Mockito.doReturn(RoleType.User).when(roleUser).getRoleType();

        roles.add(roleRootAdmin);
        roles.add(roleDomainAdmin);
        roles.add(roleResourceAdmin);
        roles.add(roleUser);

        roleManagerImpl.removeRootAdminRoles(roles);

        Assert.assertEquals(3, roles.size());
        Assert.assertEquals(roleDomainAdmin, roles.get(0));
        Assert.assertEquals(roleResourceAdmin, roles.get(1));
        Assert.assertEquals(roleUser, roles.get(2));
    }

    @Test
    public void findRolesByTypeTestNullRoleType() {
        List<Role> returnedRoles = roleManagerImpl.findRolesByType(null);

        Assert.assertEquals(0, returnedRoles.size());
        Mockito.verify(accountManagerMock, Mockito.times(0)).isRootAdmin(Mockito.anyLong());
    }

    @Test
    public void findRolesByTypeTestAdminRoleNonRootAdminUser() {
        Mockito.doReturn(accountMock).when(roleManagerImpl).getCurrentAccount();
        Mockito.doReturn(false).when(accountManagerMock).isRootAdmin(accountMockId);

        List<Role> returnedRoles = roleManagerImpl.findRolesByType(RoleType.Admin);

        Assert.assertEquals(0, returnedRoles.size());
        Mockito.verify(accountManagerMock, Mockito.times(1)).isRootAdmin(Mockito.anyLong());
        Mockito.verify(roleDaoMock, Mockito.times(0)).findAllByRoleType(Mockito.any(RoleType.class));
    }

    @Test
    public void findRolesByTypeTestAdminRoleRootAdminUser() {
        Mockito.doReturn(accountMock).when(roleManagerImpl).getCurrentAccount();
        Mockito.doReturn(true).when(accountManagerMock).isRootAdmin(accountMockId);

        List<Role> roles = new ArrayList<>();
        roles.add(Mockito.mock(Role.class));
        Mockito.doReturn(roles).when(roleDaoMock).findAllByRoleType(RoleType.Admin);
        List<Role> returnedRoles = roleManagerImpl.findRolesByType(RoleType.Admin);

        Assert.assertEquals(1, returnedRoles.size());
        Mockito.verify(accountManagerMock, Mockito.times(1)).isRootAdmin(Mockito.anyLong());
        Mockito.verify(roleDaoMock, Mockito.times(1)).findAllByRoleType(Mockito.any(RoleType.class));
    }

    @Test
    public void findRolesByTypeTestNonAdminRoleRootAdminUser() {
        Mockito.doReturn(accountMock).when(roleManagerImpl).getCurrentAccount();
        Mockito.doReturn(true).when(accountManagerMock).isRootAdmin(accountMockId);

        List<Role> roles = new ArrayList<>();
        roles.add(Mockito.mock(Role.class));
        Mockito.doReturn(roles).when(roleDaoMock).findAllByRoleType(RoleType.User);
        List<Role> returnedRoles = roleManagerImpl.findRolesByType(RoleType.User);

        Assert.assertEquals(1, returnedRoles.size());
        Mockito.verify(accountManagerMock, Mockito.times(0)).isRootAdmin(Mockito.anyLong());
        Mockito.verify(roleDaoMock, Mockito.times(1)).findAllByRoleType(Mockito.any(RoleType.class));
    }

    @Test
    public void listRolesTest() {
        List<Role> roles = new ArrayList<>();
        roles.add(Mockito.mock(Role.class));

        Mockito.doReturn(roles).when(roleDaoMock).listAll();
        Mockito.doNothing().when(roleManagerImpl).removeRootAdminRolesIfNeeded(roles);

        List<Role> returnedRoles = roleManagerImpl.listRoles();

        Assert.assertEquals(roles.size(), returnedRoles.size());
        Mockito.verify(roleDaoMock).listAll();
        Mockito.verify(roleManagerImpl).removeRootAdminRolesIfNeeded(roles);
    }
}