// 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
// 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.cloud.resourcelimit;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.cloudstack.api.response.AccountResponse;
import org.apache.cloudstack.api.response.DomainResponse;
import org.apache.cloudstack.api.response.TaggedResourceLimitAndCountResponse;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.apache.cloudstack.reservation.dao.ReservationDao;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.After;
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.junit.MockitoJUnitRunner;

import com.cloud.api.query.dao.UserVmJoinDao;
import com.cloud.api.query.vo.UserVmJoinVO;
import com.cloud.configuration.Resource;
import com.cloud.configuration.ResourceCountVO;
import com.cloud.configuration.ResourceLimit;
import com.cloud.configuration.ResourceLimitVO;
import com.cloud.configuration.dao.ResourceCountDao;
import com.cloud.configuration.dao.ResourceLimitDao;
import com.cloud.domain.Domain;
import com.cloud.domain.DomainVO;
import com.cloud.domain.dao.DomainDao;
import com.cloud.exception.ResourceAllocationException;
import com.cloud.offering.DiskOffering;
import com.cloud.offering.ServiceOffering;
import com.cloud.projects.ProjectVO;
import com.cloud.projects.dao.ProjectDao;
import com.cloud.service.ServiceOfferingVO;
import com.cloud.service.dao.ServiceOfferingDao;
import com.cloud.storage.DiskOfferingVO;
import com.cloud.storage.VMTemplateVO;
import com.cloud.storage.VolumeVO;
import com.cloud.storage.dao.DiskOfferingDao;
import com.cloud.storage.dao.VMTemplateDao;
import com.cloud.storage.dao.VolumeDao;
import com.cloud.template.VirtualMachineTemplate;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountVO;
import com.cloud.user.ResourceLimitService;
import com.cloud.user.dao.AccountDao;
import com.cloud.utils.Pair;
import com.cloud.vm.VirtualMachine;
import com.cloud.vm.VirtualMachineManager;
import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.dao.VMInstanceDao;
import com.cloud.vpc.MockResourceLimitManagerImpl;

import junit.framework.TestCase;

@RunWith(MockitoJUnitRunner.class)
public class ResourceLimitManagerImplTest extends TestCase {
    private Logger logger = LogManager.getLogger(ResourceLimitManagerImplTest.class);

    MockResourceLimitManagerImpl _resourceLimitService = new MockResourceLimitManagerImpl();

    @Spy
    @InjectMocks
    ResourceLimitManagerImpl resourceLimitManager;

    @Mock
    VMInstanceDao vmDao;
    @Mock
    AccountDao accountDao;
    @Mock
    AccountManager accountManager;
    @Mock
    ResourceLimitDao resourceLimitDao;
    @Mock
    DomainDao domainDao;
    @Mock
    ProjectDao projectDao;
    @Mock
    ResourceCountDao resourceCountDao;
    @Mock
    private ReservationDao reservationDao;
    @Mock
    UserVmJoinDao userVmJoinDao;
    @Mock
    ServiceOfferingDao serviceOfferingDao;
    @Mock
    VMTemplateDao vmTemplateDao;
    @Mock
    DiskOfferingDao diskOfferingDao;
    @Mock
    VolumeDao volumeDao;
    @Mock
    UserVmDao userVmDao;

    private List<String> hostTags = List.of("htag1", "htag2", "htag3");
    private List<String> storageTags = List.of("stag1", "stag2");

    private void overrideDefaultConfigValue(final ConfigKey configKey, final String name, final Object o) throws IllegalAccessException, NoSuchFieldException {
        Field f = ConfigKey.class.getDeclaredField(name);
        f.setAccessible(true);
        f.set(configKey, o);
    }

    @Before
    public void setUp() {
        try {
            overrideDefaultConfigValue(ResourceLimitService.ResourceLimitHostTags, "_defaultValue", StringUtils.join(hostTags, ","));
            overrideDefaultConfigValue(ResourceLimitService.ResourceLimitStorageTags, "_defaultValue", StringUtils.join(storageTags, ","));
        } catch (IllegalAccessException | NoSuchFieldException e) {
            logger.error("Failed to update configurations");
        }
    }

    @After
    public void tearDown() throws Exception {
    }

    @Test
    public void testInjected() throws Exception {
        logger.info("Starting test for Resource Limit manager");
        updateResourceCount();
        updateResourceLimit();
        //listResourceLimits();
        logger.info("Resource Limit Manager: TEST PASSED");
    }

    protected void updateResourceCount() {
        // update resource count for an account
        Long accountId = (long)1;
        Long domainId = (long)1;
        String msg = "Update Resource Count for account: TEST FAILED";
        Assert.assertNull(msg, _resourceLimitService.recalculateResourceCount(accountId, domainId, null));

        // update resource count for a domain
        accountId = null;
        msg = "Update Resource Count for domain: TEST FAILED";
        Assert.assertNull(msg, _resourceLimitService.recalculateResourceCount(accountId, domainId, null));
    }

    protected void updateResourceLimit() {
        // update resource Limit for an account for resource_type = 8 (CPU)
        resourceLimitServiceCall((long)1, (long)1, 8, (long)20);

        // update resource Limit for a domain for resource_type = 8 (CPU)
        resourceLimitServiceCall(null, (long)1, 8, (long)40);

        // update resource Limit for an account for resource_type = 9 (Memory (in MiB))
        resourceLimitServiceCall((long)1, (long)1, 9, (long)4096);

        // update resource Limit for a domain for resource_type = 9 (Memory (in MiB))
        resourceLimitServiceCall(null, (long)1, 9, (long)10240);

        // update resource Limit for an account for resource_type = 10 (Primary storage (in GiB))
        resourceLimitServiceCall((long)1, (long)1, 10, (long)200);

        // update resource Limit for a domain for resource_type = 10 (Primary storage (in GiB))
        resourceLimitServiceCall(null, (long)1, 10, (long)200);

        // update resource Limit for an account for resource_type = 11 (Secondary storage (in GiB))
        resourceLimitServiceCall((long)1, (long)1, 10, (long)400);

        // update resource Limit for a domain for resource_type = 11 (Secondary storage (in GiB))
        resourceLimitServiceCall(null, (long)1, 10, (long)400);
    }

    private void resourceLimitServiceCall(Long accountId, Long domainId, Integer resourceType, Long max) {
        String msg = "Update Resource Limit: TEST FAILED";
        ResourceLimit result = null;
        try {
            result = _resourceLimitService.updateResourceLimit(accountId, domainId, resourceType, max, null);
            Assert.assertFalse(msg, (result != null || (result == null && max != null && max.longValue() == -1L)));
        } catch (Exception ex) {
            Assert.fail(msg);
        }
    }

    @Test
    public void testRemoveUndesiredTaggedLimits() {
        String desiredTag = "tag1";
        String undesiredTag = "tag2";
        List<ResourceLimitVO> limits = new ArrayList<>();
        limits.add(new ResourceLimitVO(Resource.ResourceType.cpu, 100L, 1L, Resource.ResourceOwnerType.Account, desiredTag));
        limits.add(new ResourceLimitVO(Resource.ResourceType.cpu, 100L, 1L, Resource.ResourceOwnerType.Account, undesiredTag));
        resourceLimitManager.removeUndesiredTaggedLimits(limits, List.of(desiredTag), null);
        Assert.assertEquals(1, limits.size());
        Assert.assertEquals(desiredTag, limits.get(0).getTag());
    }

    @Test
    public void testGetResourceLimitHostTags() {
        List<String> tags = resourceLimitManager.getResourceLimitHostTags();
        Assert.assertEquals(3, tags.size());
        for (int i = 0; i < tags.size(); ++i) {
            Assert.assertEquals(hostTags.get(i), tags.get(i));
        }
    }

    @Test
    public void testGetResourceLimitHostTags1() {
        ServiceOffering serviceOffering = Mockito.mock(ServiceOffering.class);
        VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);
        Mockito.when(serviceOffering.getHostTag()).thenReturn(hostTags.get(0));
        Mockito.when(template.getTemplateTag()).thenReturn(hostTags.get(1));
        List<String> tags = resourceLimitManager.getResourceLimitHostTags(serviceOffering, template);
        Assert.assertEquals(2, tags.size());
        Assert.assertEquals(hostTags.get(0), tags.get(0));
        Assert.assertEquals(hostTags.get(1), tags.get(1));
    }

    @Test
    public void testGetResourceLimitStorageTags() {
        List<String> tags = resourceLimitManager.getResourceLimitStorageTags();
        Assert.assertEquals(2, tags.size());
        for (int i = 0; i < tags.size(); ++i) {
            Assert.assertEquals(storageTags.get(i), tags.get(i));
        }
    }

    @Test
    public void testGetResourceLimitStorageTags1() {
        DiskOffering diskOffering = Mockito.mock(DiskOffering.class);
        Mockito.when(diskOffering.getTags()).thenReturn(storageTags.get(1));
        Mockito.when(diskOffering.getTagsArray()).thenReturn(new String[]{storageTags.get(1)});
        List<String> tags = resourceLimitManager.getResourceLimitStorageTags(diskOffering);
        Assert.assertEquals(1, tags.size());
        Assert.assertEquals(storageTags.get(1), tags.get(0));
    }

    @Test
    public void testCheckVmResourceLimit() {
        ServiceOffering serviceOffering = Mockito.mock(ServiceOffering.class);
        VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);
        Mockito.when(serviceOffering.getHostTag()).thenReturn(hostTags.get(0));
        Mockito.when(serviceOffering.getCpu()).thenReturn(2);
        Mockito.when(serviceOffering.getRamSize()).thenReturn(256);
        Mockito.when(template.getTemplateTag()).thenReturn(hostTags.get(0));
        Account account = Mockito.mock(Account.class);
        try {
            Mockito.doNothing().when(resourceLimitManager).checkResourceLimitWithTag(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
            resourceLimitManager.checkVmResourceLimit(account, true, serviceOffering, template);
            List<String> tags = new ArrayList<>();
            tags.add(null);
            tags.add(hostTags.get(0));
            for (String tag: tags) {
                Mockito.verify(resourceLimitManager, Mockito.times(1)).checkResourceLimitWithTag(account, Resource.ResourceType.user_vm, tag);
                Mockito.verify(resourceLimitManager, Mockito.times(1)).checkResourceLimitWithTag(account, Resource.ResourceType.cpu, tag, 2L);
                Mockito.verify(resourceLimitManager, Mockito.times(1)).checkResourceLimitWithTag(account, Resource.ResourceType.memory, tag, 256L);
            }
        } catch (ResourceAllocationException e) {
            Assert.fail("Exception encountered: " + e.getMessage());
        }
    }

    @Test
    public void testCheckVmCpuResourceLimit() {
        ServiceOffering serviceOffering = Mockito.mock(ServiceOffering.class);
        VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);
        Mockito.when(serviceOffering.getHostTag()).thenReturn(hostTags.get(0));
        Mockito.when(template.getTemplateTag()).thenReturn(hostTags.get(0));
        Account account = Mockito.mock(Account.class);
        long cpu = 2L;
        try {
            Mockito.doNothing().when(resourceLimitManager).checkResourceLimitWithTag(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
            resourceLimitManager.checkVmCpuResourceLimit(account, true, serviceOffering, template, cpu);
            Mockito.verify(resourceLimitManager, Mockito.times(1)).checkResourceLimitWithTag(account, Resource.ResourceType.cpu, null, cpu);
            Mockito.verify(resourceLimitManager, Mockito.times(1)).checkResourceLimitWithTag(account, Resource.ResourceType.cpu, hostTags.get(0), cpu);
        } catch (ResourceAllocationException e) {
            Assert.fail("Exception encountered: " + e.getMessage());
        }
    }

    @Test
    public void testCheckVmMemoryResourceLimit() {
        ServiceOffering serviceOffering = Mockito.mock(ServiceOffering.class);
        VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);
        Mockito.when(serviceOffering.getHostTag()).thenReturn(hostTags.get(0));
        Mockito.when(template.getTemplateTag()).thenReturn(hostTags.get(0));
        Account account = Mockito.mock(Account.class);
        long delta = 256L;
        try {
            Mockito.doNothing().when(resourceLimitManager).checkResourceLimitWithTag(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
            resourceLimitManager.checkVmMemoryResourceLimit(account, true, serviceOffering, template, delta);
            Mockito.verify(resourceLimitManager, Mockito.times(1)).checkResourceLimitWithTag(account, Resource.ResourceType.memory, null, delta);
            Mockito.verify(resourceLimitManager, Mockito.times(1)).checkResourceLimitWithTag(account, Resource.ResourceType.memory, hostTags.get(0), delta);
        } catch (ResourceAllocationException e) {
            Assert.fail("Exception encountered: " + e.getMessage());
        }
    }

    @Test
    public void testCheckVolumeResourceLimit() {
        String checkTag = storageTags.get(0);
        DiskOffering diskOffering = Mockito.mock(DiskOffering.class);
        Mockito.when(diskOffering.getTags()).thenReturn(checkTag);
        Mockito.when(diskOffering.getTagsArray()).thenReturn(new String[]{checkTag});
        Account account = Mockito.mock(Account.class);
        try {
            Mockito.doNothing().when(resourceLimitManager).checkResourceLimitWithTag(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
            resourceLimitManager.checkVolumeResourceLimit(account, true, 100L, diskOffering);
            List<String> tags = new ArrayList<>();
            tags.add(null);
            tags.add(checkTag);
            for (String tag: tags) {
                Mockito.verify(resourceLimitManager, Mockito.times(1)).checkResourceLimitWithTag(account, Resource.ResourceType.volume, tag);
                Mockito.verify(resourceLimitManager, Mockito.times(1)).checkResourceLimitWithTag(account, Resource.ResourceType.primary_storage, tag, 100L);
            }
        } catch (ResourceAllocationException e) {
            Assert.fail("Exception encountered: " + e.getMessage());
        }
    }

    @Test
    public void testGetResourceLimitTagsForLimitSearch() {
        Pair<List<String>, List<String>> result = resourceLimitManager.getResourceLimitTagsForLimitSearch(null);
        Assert.assertEquals(hostTags, result.first());
        Assert.assertEquals(storageTags, result.second());
        String nonExistentTag = "sometag";
        result = resourceLimitManager.getResourceLimitTagsForLimitSearch(nonExistentTag);
        Assert.assertTrue(CollectionUtils.isEmpty(result.first()));
        Assert.assertTrue(CollectionUtils.isEmpty(result.second()));
        String hostTag = "htag2";
        result = resourceLimitManager.getResourceLimitTagsForLimitSearch(hostTag);
        Assert.assertTrue(CollectionUtils.isNotEmpty(result.first()));
        Assert.assertEquals(1, result.first().size());
        Assert.assertEquals(hostTag, result.first().get(0));
        Assert.assertTrue(CollectionUtils.isEmpty(result.second()));
        String storageTag = "stag1";
        result = resourceLimitManager.getResourceLimitTagsForLimitSearch(storageTag);
        Assert.assertTrue(CollectionUtils.isNotEmpty(result.second()));
        Assert.assertEquals(1, result.second().size());
        Assert.assertEquals(storageTag, result.second().get(0));
        Assert.assertTrue(CollectionUtils.isEmpty(result.first()));
    }

    @Test
    public void testIsTaggedResourceCountRecalculationNotNeeded() {
        Assert.assertTrue(resourceLimitManager.isTaggedResourceCountRecalculationNotNeeded(
                Resource.ResourceType.network, List.of("h1", "h2"), List.of("s1", "s2")));
        Assert.assertTrue(resourceLimitManager.isTaggedResourceCountRecalculationNotNeeded(
                Resource.ResourceType.cpu, new ArrayList<>(), new ArrayList<>()));
        Assert.assertFalse(resourceLimitManager.isTaggedResourceCountRecalculationNotNeeded(
                Resource.ResourceType.cpu, List.of("h1", "h2"), new ArrayList<>()));
    }

    @Test
    public void testAddTaggedResourceLimits() {
        List<ResourceLimitVO> limits = new ArrayList<>();
        resourceLimitManager.addTaggedResourceLimits(limits, null, hostTags, Resource.ResourceOwnerType.Account, 1L);
        Assert.assertTrue(CollectionUtils.isEmpty(limits));
        resourceLimitManager.addTaggedResourceLimits(limits, List.of(Resource.ResourceType.cpu), null, Resource.ResourceOwnerType.Account, 1L);
        Assert.assertTrue(CollectionUtils.isEmpty(limits));
        limits = new ArrayList<>();
        limits.add(Mockito.mock(ResourceLimitVO.class));
        int size = limits.size();
        AccountVO account = Mockito.mock(AccountVO.class);
        Mockito.when(account.getId()).thenReturn(1L);
        Mockito.when(accountDao.findById(1L)).thenReturn(account);
        Mockito.when(accountManager.isRootAdmin(1L)).thenReturn(true);
        resourceLimitManager.addTaggedResourceLimits(limits, List.of(Resource.ResourceType.cpu), hostTags, Resource.ResourceOwnerType.Account, 1L);
        Assert.assertEquals(size + hostTags.size(), limits.size());
    }

    @Test
    public void testFindCorrectResourceLimitForAccount() {
        AccountVO account = Mockito.mock(AccountVO.class);
        Mockito.when(account.getId()).thenReturn(1L);
        Mockito.when(accountManager.isRootAdmin(1L)).thenReturn(true);
        long result = resourceLimitManager.findCorrectResourceLimitForAccount(account, Resource.ResourceType.cpu, hostTags.get(0));
        Assert.assertEquals(Resource.RESOURCE_UNLIMITED, result);

        Mockito.when(accountManager.isRootAdmin(1L)).thenReturn(false);
        ResourceLimitVO limit = new ResourceLimitVO();
        limit.setMax(10L);
        Mockito.when(resourceLimitDao.findByOwnerIdAndTypeAndTag(1L, Resource.ResourceOwnerType.Account, Resource.ResourceType.cpu, hostTags.get(0))).thenReturn(limit);
        result = resourceLimitManager.findCorrectResourceLimitForAccount(account, Resource.ResourceType.cpu, hostTags.get(0));
        Assert.assertEquals(10L, result);

        long defaultAccountCpuMax = 25L;
        Map<String, Long> accountResourceLimitMap = new HashMap<>();
        accountResourceLimitMap.put(Resource.ResourceType.cpu.name(), defaultAccountCpuMax);
        resourceLimitManager.accountResourceLimitMap = accountResourceLimitMap;
        Mockito.when(resourceLimitDao.findByOwnerIdAndTypeAndTag(1L, Resource.ResourceOwnerType.Account, Resource.ResourceType.cpu, hostTags.get(0))).thenReturn(null);
        result = resourceLimitManager.findCorrectResourceLimitForAccount(account, Resource.ResourceType.cpu, hostTags.get(0));
        Assert.assertEquals(defaultAccountCpuMax, result);
    }

    @Test
    public void testFindCorrectResourceLimitForAccountId1() {
//        long accountId = 1L;
//        Mockito.when(accountManager.isRootAdmin(accountId)).thenReturn(true);
//        long result = resourceLimitManager.findCorrectResourceLimitForAccount(accountId, null, Resource.ResourceType.cpu);
//        Assert.assertEquals(Resource.RESOURCE_UNLIMITED, result);
//
//        accountId = 2L;
//        Mockito.when(accountManager.isRootAdmin(accountId)).thenReturn(false);
//        Long limit = 100L;
//        long result = resourceLimitManager.findCorrectResourceLimitForAccount(accountId, limit, Resource.ResourceType.cpu);
//        Assert.assertEquals(limit.longValue(), result);
//
//        long defaultAccountCpuMax = 25L;
//        Mockito.when(accountManager.isRootAdmin(accountId)).thenReturn(false);
//        Map<String, Long> accountResourceLimitMap = new HashMap<>();
//        accountResourceLimitMap.put(Resource.ResourceType.cpu.name(), defaultAccountCpuMax);
//        resourceLimitManager.accountResourceLimitMap = accountResourceLimitMap;
//        result = resourceLimitManager.findCorrectResourceLimitForAccount(accountId, null, Resource.ResourceType.cpu);
//        Assert.assertEquals(defaultAccountCpuMax, result);
    }

    @Test
    public void testFindCorrectResourceLimitForDomain() {
        DomainVO domain = Mockito.mock(DomainVO.class);
        Mockito.when(domain.getId()).thenReturn(1L);
        long result = resourceLimitManager.findCorrectResourceLimitForDomain(domain, Resource.ResourceType.cpu, hostTags.get(0));
        Assert.assertEquals(Resource.RESOURCE_UNLIMITED, result);

        Mockito.when(domain.getId()).thenReturn(2L);
        Mockito.when(domain.getParent()).thenReturn(null);
        ResourceLimitVO limit = new ResourceLimitVO();
        limit.setMax(100L);
        Mockito.when(resourceLimitDao.findByOwnerIdAndTypeAndTag(2L, Resource.ResourceOwnerType.Domain, Resource.ResourceType.cpu, hostTags.get(0))).thenReturn(limit);
        result = resourceLimitManager.findCorrectResourceLimitForDomain(domain, Resource.ResourceType.cpu, hostTags.get(0));
        Assert.assertEquals(100L, result);

        Mockito.when(domain.getId()).thenReturn(3L);
        DomainVO parentDomain = Mockito.mock(DomainVO.class);
        Mockito.when(domain.getParent()).thenReturn(5L);
        Mockito.when(domainDao.findById(5L)).thenReturn(parentDomain);
        limit = new ResourceLimitVO();
        limit.setMax(200L);
        Mockito.when(resourceLimitDao.findByOwnerIdAndTypeAndTag(3L, Resource.ResourceOwnerType.Domain, Resource.ResourceType.cpu, hostTags.get(0))).thenReturn(null);
        Mockito.when(resourceLimitDao.findByOwnerIdAndTypeAndTag(5L, Resource.ResourceOwnerType.Domain, Resource.ResourceType.cpu, hostTags.get(0))).thenReturn(limit);
        result = resourceLimitManager.findCorrectResourceLimitForDomain(domain, Resource.ResourceType.cpu, hostTags.get(0));
        Assert.assertEquals(200L, result);

        long defaultDomainCpuMax = 250L;
        Mockito.when(domain.getId()).thenReturn(4L);
        Mockito.when(domain.getParent()).thenReturn(null);
        Map<String, Long> domainResourceLimitMap = new HashMap<>();
        domainResourceLimitMap.put(Resource.ResourceType.cpu.name(), defaultDomainCpuMax);
        resourceLimitManager.domainResourceLimitMap = domainResourceLimitMap;
        Mockito.when(resourceLimitDao.findByOwnerIdAndTypeAndTag(4L, Resource.ResourceOwnerType.Domain, Resource.ResourceType.cpu, hostTags.get(0))).thenReturn(null);
        result = resourceLimitManager.findCorrectResourceLimitForDomain(domain, Resource.ResourceType.cpu, hostTags.get(0));
        Assert.assertEquals(defaultDomainCpuMax, result);
    }

    @Test
    public void testCheckResourceLimitWithTag() {
        AccountVO account = Mockito.mock(AccountVO.class);
        Mockito.when(account.getId()).thenReturn(1L);
        Mockito.when(accountManager.isRootAdmin(1L)).thenReturn(true);
        try {
            resourceLimitManager.checkResourceLimitWithTag(account, Resource.ResourceType.cpu, hostTags.get(0), 1);
        } catch (ResourceAllocationException e) {
            Assert.fail(e.getMessage());
        }
    }

    @Test
    public void testCheckResourceLimitWithTagNonAdmin() throws ResourceAllocationException {
        AccountVO account = Mockito.mock(AccountVO.class);
        Mockito.when(account.getId()).thenReturn(1L);
        Mockito.when(accountManager.isRootAdmin(1L)).thenReturn(false);
        Mockito.doReturn(new ArrayList<ResourceLimitVO>()).when(resourceLimitManager).lockAccountAndOwnerDomainRows(Mockito.anyLong(), Mockito.any(Resource.ResourceType.class), Mockito.anyString());
        Mockito.doNothing().when(resourceLimitManager).checkAccountResourceLimit(account, null, Resource.ResourceType.cpu, hostTags.get(0), 1);
        Mockito.doNothing().when(resourceLimitManager).checkDomainResourceLimit(account, null, Resource.ResourceType.cpu, hostTags.get(0), 1);
        try {
            resourceLimitManager.checkResourceLimitWithTag(account, Resource.ResourceType.cpu, hostTags.get(0), 1);
        } catch (ResourceAllocationException e) {
            Assert.fail(e.getMessage());
        }
    }

    @Test
    public void testCheckResourceLimitWithTagProject() throws ResourceAllocationException {
        AccountVO account = Mockito.mock(AccountVO.class);
        Mockito.when(account.getId()).thenReturn(1L);
        Mockito.when(account.getType()).thenReturn(Account.Type.PROJECT);
        Mockito.when(accountManager.isRootAdmin(1L)).thenReturn(false);
        ProjectVO projectVO = Mockito.mock(ProjectVO.class);
        Mockito.when(projectDao.findByProjectAccountId(Mockito.anyLong())).thenReturn(projectVO);
        Mockito.doReturn(new ArrayList<ResourceLimitVO>()).when(resourceLimitManager).lockAccountAndOwnerDomainRows(Mockito.anyLong(), Mockito.any(Resource.ResourceType.class), Mockito.anyString());
        Mockito.doNothing().when(resourceLimitManager).checkAccountResourceLimit(account, projectVO, Resource.ResourceType.cpu, hostTags.get(0), 1);
        Mockito.doNothing().when(resourceLimitManager).checkDomainResourceLimit(account, projectVO, Resource.ResourceType.cpu, hostTags.get(0), 1);
        try {
            resourceLimitManager.checkResourceLimitWithTag(account, Resource.ResourceType.cpu, hostTags.get(0), 1);
        } catch (ResourceAllocationException e) {
            Assert.fail(e.getMessage());
        }
    }

    @Test
    public void testRemoveResourceLimitAndCountForNonMatchingTags() {
        resourceLimitManager.removeResourceLimitAndCountForNonMatchingTags(1L, Resource.ResourceOwnerType.Account, hostTags, storageTags);
        Mockito.verify(resourceLimitDao, Mockito.times(1))
                .removeResourceLimitsForNonMatchingTags(1L, Resource.ResourceOwnerType.Account, ResourceLimitService.HostTagsSupportingTypes, hostTags);
        Mockito.verify(resourceLimitDao, Mockito.times(1))
                .removeResourceLimitsForNonMatchingTags(1L, Resource.ResourceOwnerType.Account, ResourceLimitService.StorageTagsSupportingTypes, storageTags);
        Mockito.verify(resourceCountDao, Mockito.times(1))
                .removeResourceCountsForNonMatchingTags(1L, Resource.ResourceOwnerType.Account, ResourceLimitService.HostTagsSupportingTypes, hostTags);
        Mockito.verify(resourceCountDao, Mockito.times(1))
                .removeResourceCountsForNonMatchingTags(1L, Resource.ResourceOwnerType.Account, ResourceLimitService.StorageTagsSupportingTypes, storageTags);
    }

    @Test
    public void testRecalculateAccountTaggedResourceCountNegative() {
        List<ResourceCountVO> result = resourceLimitManager.recalculateAccountTaggedResourceCount(1L, Resource.ResourceType.network, hostTags, storageTags);
        CollectionUtils.isEmpty(result);
        result = resourceLimitManager.recalculateAccountTaggedResourceCount(1L, Resource.ResourceType.cpu, null, storageTags);
        CollectionUtils.isEmpty(result);
        result = resourceLimitManager.recalculateAccountTaggedResourceCount(1L, Resource.ResourceType.volume, hostTags, null);
        CollectionUtils.isEmpty(result);
    }

    @Test
    public void testRecalculateAccountTaggedResourceCountHostTypes() {
        long accountId = 1L;
        Resource.ResourceType type = Resource.ResourceType.cpu;
        for (String tag: hostTags) {
            Mockito.doReturn(10L).when(resourceLimitManager).recalculateAccountResourceCount(accountId, type, tag);
        }
        List<ResourceCountVO> result = resourceLimitManager.recalculateAccountTaggedResourceCount(accountId, type, hostTags, storageTags);
        Assert.assertEquals(hostTags.size(), result.size());
    }

    @Test
    public void testRecalculateAccountTaggedResourceCountStorageTypes() {
        long accountId = 1L;
        Resource.ResourceType type = Resource.ResourceType.volume;
        for (String tag: storageTags) {
            Mockito.doReturn(10L).when(resourceLimitManager).recalculateAccountResourceCount(accountId, type, tag);
        }
        List<ResourceCountVO> result = resourceLimitManager.recalculateAccountTaggedResourceCount(accountId, type, hostTags, storageTags);
        Assert.assertEquals(storageTags.size(), result.size());
    }

    @Test
    public void testRecalculateDomainTaggedResourceCountNegative() {
        List<ResourceCountVO> result = resourceLimitManager.recalculateDomainTaggedResourceCount(1L, Resource.ResourceType.network, hostTags, storageTags);
        CollectionUtils.isEmpty(result);
        result = resourceLimitManager.recalculateDomainTaggedResourceCount(1L, Resource.ResourceType.cpu, null, storageTags);
        CollectionUtils.isEmpty(result);
        result = resourceLimitManager.recalculateDomainTaggedResourceCount(1L, Resource.ResourceType.volume, hostTags, null);
        CollectionUtils.isEmpty(result);
    }

    @Test
    public void testRecalculateDomainTaggedResourceCountHostTypes() {
        long domainId = 1L;
        Resource.ResourceType type = Resource.ResourceType.cpu;
        for (String tag: hostTags) {
            Mockito.doReturn(10L).when(resourceLimitManager).recalculateDomainResourceCount(domainId, type, tag);
        }
        List<ResourceCountVO> result = resourceLimitManager.recalculateDomainTaggedResourceCount(domainId, type, hostTags, storageTags);
        Assert.assertEquals(hostTags.size(), result.size());
    }

    @Test
    public void testRecalculateDomainTaggedResourceCountStorageTypes() {
        long domainId = 1L;
        Resource.ResourceType type = Resource.ResourceType.volume;
        for (String tag: storageTags) {
            Mockito.doReturn(10L).when(resourceLimitManager).recalculateDomainResourceCount(domainId, type, tag);
        }
        List<ResourceCountVO> result = resourceLimitManager.recalculateDomainTaggedResourceCount(domainId, type, hostTags, storageTags);
        Assert.assertEquals(storageTags.size(), result.size());
    }

    @Test
    public void testRecalculateResourceCount() {
        Long accountId = 1L;
        Long domainId = null;
        Integer typeId = Resource.ResourceType.user_vm.getOrdinal();
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager).recalculateResourceCount(accountId, domainId, typeId, null);
        resourceLimitManager.recalculateResourceCount(accountId, domainId, typeId);
        Mockito.verify(resourceLimitManager, Mockito.times(1)).recalculateResourceCount(accountId, domainId, typeId, null);
    }

    @Test
    public void testGetVmsWithAccountAndTagNoTag() throws NoSuchFieldException, IllegalAccessException {
        overrideDefaultConfigValue(VirtualMachineManager.ResourceCountRunningVMsonly, "_defaultValue", "false");
        List<VirtualMachine.State> states = Arrays.asList(VirtualMachine.State.Destroyed, VirtualMachine.State.Error, VirtualMachine.State.Expunging);
        List<UserVmJoinVO> vmList = List.of(Mockito.mock(UserVmJoinVO.class));
        Mockito.when(userVmJoinDao.listByAccountServiceOfferingTemplateAndNotInState(1L, states, null, null)).thenReturn(vmList);
        List<UserVmJoinVO> result = resourceLimitManager.getVmsWithAccountAndTag(1L, null);
        Assert.assertEquals(vmList.size(), result.size());
    }

    @Test
    public void testGetVmsWithAccountAndTagNegative() {
        String tag = hostTags.get(0);
        Mockito.when(serviceOfferingDao.listByHostTag(tag)).thenReturn(null);
        Mockito.when(vmTemplateDao.listByTemplateTag(tag)).thenReturn(null);
        List<UserVmJoinVO> result = resourceLimitManager.getVmsWithAccountAndTag(1L, hostTags.get(0));
        Assert.assertTrue(CollectionUtils.isEmpty(result));
    }

    @Test
    public void testGetVmsWithAccountAndTag() throws NoSuchFieldException, IllegalAccessException {
        overrideDefaultConfigValue(VirtualMachineManager.ResourceCountRunningVMsonly, "_defaultValue", "true");
        String tag = hostTags.get(0);
        ServiceOfferingVO serviceOfferingVO = Mockito.mock(ServiceOfferingVO.class);
        Mockito.when(serviceOfferingVO.getId()).thenReturn(1L);
        VMTemplateVO templateVO = Mockito.mock(VMTemplateVO.class);
        Mockito.when(templateVO.getId()).thenReturn(1L);
        Mockito.when(serviceOfferingDao.listByHostTag(tag)).thenReturn(List.of(serviceOfferingVO));
        Mockito.when(vmTemplateDao.listByTemplateTag(tag)).thenReturn(List.of(templateVO));
        List<UserVmJoinVO> vmList = List.of(Mockito.mock(UserVmJoinVO.class));
        Mockito.when(userVmJoinDao.listByAccountServiceOfferingTemplateAndNotInState(Mockito.anyLong(), Mockito.anyList(), Mockito.anyList(), Mockito.anyList())).thenReturn(vmList);
        List<UserVmJoinVO> result = resourceLimitManager.getVmsWithAccountAndTag(1L, tag);
        Assert.assertEquals(vmList.size(), result.size());
    }

    @Test
    public void testGetVmsWithAccount() {
        long accountId = 1L;
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager).getVmsWithAccountAndTag(accountId, null);
        resourceLimitManager.getVmsWithAccount(accountId);
        Mockito.verify(resourceLimitManager, Mockito.times(1)).getVmsWithAccountAndTag(accountId, null);
    }

    @Test
    public void testGetVolumesWithAccountAndTag() {
        long accountId = 1L;
        String tag = "tag";
        Mockito.when(diskOfferingDao.listByStorageTag(tag)).thenReturn(new ArrayList<>());
        Assert.assertTrue(CollectionUtils.isEmpty(resourceLimitManager.getVolumesWithAccountAndTag(accountId, tag)));

        Mockito.when(diskOfferingDao.listByStorageTag(tag)).thenReturn(List.of(Mockito.mock(DiskOfferingVO.class)));
        Mockito.when(vmDao.findIdsOfAllocatedVirtualRoutersForAccount(accountId)).thenReturn(List.of(1L));
        Mockito.when(volumeDao.listAllocatedVolumesForAccountDiskOfferingIdsAndNotForVms(
                Mockito.anyLong(), Mockito.anyList(), Mockito.anyList()))
                .thenReturn(List.of(Mockito.mock(VolumeVO.class)));
        List<VolumeVO> result = resourceLimitManager.getVolumesWithAccountAndTag(accountId, tag);
        Assert.assertTrue(CollectionUtils.isNotEmpty(resourceLimitManager.getVolumesWithAccountAndTag(accountId, tag)));
        Assert.assertEquals(1, result.size());
    }

    @Test
    public void testCalculateVmCountForAccount() {
        long accountId = 1L;
        String tag = null;
        Mockito.when(userVmDao.countAllocatedVMsForAccount(Mockito.eq(accountId), Mockito.anyBoolean()))
                .thenReturn(1L);
        Assert.assertEquals(1L, resourceLimitManager.calculateVmCountForAccount(accountId, tag));

        tag = "";
        Mockito.when(userVmDao.countAllocatedVMsForAccount(Mockito.eq(accountId), Mockito.anyBoolean()))
                .thenReturn(2L);
        Assert.assertEquals(2L, resourceLimitManager.calculateVmCountForAccount(accountId, tag));

        tag = "tag";
        UserVmJoinVO vm = Mockito.mock(UserVmJoinVO.class);
        Mockito.when(vm.getId()).thenReturn(1L);
        Mockito.doReturn(List.of(vm)).when(resourceLimitManager).getVmsWithAccountAndTag(accountId, tag);
        Assert.assertEquals(1L, resourceLimitManager.calculateVmCountForAccount(accountId, tag));
    }

    @Test
    public void testCalculateVolumeCountForAccount() {
        long accountId = 1L;
        String tag = null;
        Mockito.when(vmDao.findIdsOfAllocatedVirtualRoutersForAccount(accountId))
                .thenReturn(List.of(1L));
        Mockito.when(volumeDao.countAllocatedVolumesForAccount(accountId)).thenReturn(3L);
        Assert.assertEquals(2L, resourceLimitManager.calculateVolumeCountForAccount(accountId, tag));

        tag = "";
        Mockito.when(volumeDao.countAllocatedVolumesForAccount(accountId)).thenReturn(2L);
        Assert.assertEquals(1L, resourceLimitManager.calculateVolumeCountForAccount(accountId, tag));

        tag = "tag";
        Mockito.doReturn(List.of(VolumeVO.class)).when(resourceLimitManager).getVolumesWithAccountAndTag(accountId, tag);
        Assert.assertEquals(1L, resourceLimitManager.calculateVolumeCountForAccount(accountId, tag));
    }

    @Test
    public void testCalculateVmCpuCountForAccount() {
        long accountId = 1L;
        String tag = null;
        Mockito.doReturn(1L).when(resourceLimitManager).countCpusForAccount(accountId);
        Assert.assertEquals(1L, resourceLimitManager.calculateVmCpuCountForAccount(accountId, tag));

        tag = "";
        Mockito.doReturn(2L).when(resourceLimitManager).countCpusForAccount(accountId);
        Assert.assertEquals(2L, resourceLimitManager.calculateVmCpuCountForAccount(accountId, tag));

        tag = "tag";
        UserVmJoinVO vm = Mockito.mock(UserVmJoinVO.class);
        int cpu = 2;
        Mockito.when(vm.getCpu()).thenReturn(cpu);
        List<UserVmJoinVO> vms = List.of(vm, vm);
        Mockito.doReturn(vms).when(resourceLimitManager).getVmsWithAccountAndTag(accountId, tag);
        Assert.assertEquals(vms.size() * cpu, resourceLimitManager.calculateVmCpuCountForAccount(accountId, tag));
    }

    @Test
    public void testCalculateVmMemoryCountForAccount() {
        long accountId = 1L;
        String tag = null;
        Mockito.doReturn(1024L).when(resourceLimitManager).calculateMemoryForAccount(accountId);
        Assert.assertEquals(1024L, resourceLimitManager.calculateVmMemoryCountForAccount(accountId, tag));

        tag = "";
        Mockito.doReturn(2048L).when(resourceLimitManager).calculateMemoryForAccount(accountId);
        Assert.assertEquals(2048L, resourceLimitManager.calculateVmMemoryCountForAccount(accountId, tag));

        tag = "tag";
        UserVmJoinVO vm = Mockito.mock(UserVmJoinVO.class);
        int memory = 1024;
        Mockito.when(vm.getRamSize()).thenReturn(memory);
        List<UserVmJoinVO> vms = List.of(vm, vm);
        Mockito.doReturn(vms).when(resourceLimitManager).getVmsWithAccountAndTag(accountId, tag);
        Assert.assertEquals(vms.size() * memory, resourceLimitManager.calculateVmMemoryCountForAccount(accountId, tag));
    }

    @Test
    public void testCalculatePrimaryStorageForAccount() {
        long accountId = 1L;
        String tag = null;
        Mockito.when(vmDao.findIdsOfAllocatedVirtualRoutersForAccount(accountId))
                .thenReturn(List.of(1L));
        Mockito.when(volumeDao.primaryStorageUsedForAccount(Mockito.eq(accountId), Mockito.anyList())).thenReturn(100L);
        Assert.assertEquals(100L, resourceLimitManager.calculatePrimaryStorageForAccount(accountId, tag));

        tag = "";
        Mockito.when(volumeDao.primaryStorageUsedForAccount(Mockito.eq(accountId), Mockito.anyList())).thenReturn(200L);
        Assert.assertEquals(200L, resourceLimitManager.calculatePrimaryStorageForAccount(accountId, tag));

        tag = "tag";
        VolumeVO vol = Mockito.mock(VolumeVO.class);
        long size = 1024;
        Mockito.when(vol.getSize()).thenReturn(size);
        List<VolumeVO> vols = List.of(vol, vol);
        Mockito.doReturn(vols).when(resourceLimitManager).getVolumesWithAccountAndTag(accountId, tag);
        Assert.assertEquals(vols.size() * size, resourceLimitManager.calculatePrimaryStorageForAccount(accountId, tag));
    }

    @Test
    public void testGetResourceCount() {
        long accountId = 1L;
        Account account = Mockito.mock(Account.class);
        Mockito.when(account.getId()).thenReturn(accountId);
        resourceLimitManager.getResourceCount(account, Resource.ResourceType.user_vm, "tag");
        Mockito.verify(resourceCountDao, Mockito.times(1))
                .getResourceCount(accountId, Resource.ResourceOwnerType.Account, Resource.ResourceType.user_vm, "tag");
    }

    @Test
    public void testGetTaggedResourceLimitAndCountResponse() {
        long accountId = 1L;
        Account account = Mockito.mock(Account.class);
        Mockito.when(account.getId()).thenReturn(accountId);
        Long accountLimit = 10L;
        Mockito.doReturn(accountLimit).when(resourceLimitManager)
                .findCorrectResourceLimitForAccount(Mockito.any(Account.class), Mockito.any(Resource.ResourceType.class), Mockito.anyString());
        Long accountCount = 2L;
        ResourceCountVO resourceCountVO = Mockito.mock(ResourceCountVO.class);
        Mockito.when(resourceCountVO.getCount()).thenReturn(accountCount);
        Mockito.when(resourceCountDao.findByOwnerAndTypeAndTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceOwnerType.Account), Mockito.any(Resource.ResourceType.class),
                Mockito.anyString())).thenReturn(resourceCountVO);

        TaggedResourceLimitAndCountResponse res = resourceLimitManager.getTaggedResourceLimitAndCountResponse(account,
                null, Resource.ResourceOwnerType.Account, Resource.ResourceType.user_vm, "tag");
        Assert.assertEquals(accountLimit, res.getLimit());
        Assert.assertEquals(accountCount, res.getTotal());
        Long available = accountLimit - accountCount;
        Assert.assertEquals(available, res.getAvailable());


        long domainId = 1L;
        Domain domain = Mockito.mock(Domain.class);
        Mockito.when(domain.getId()).thenReturn(domainId);
        Long domainLimit = 20L;
        Mockito.doReturn(domainLimit).when(resourceLimitManager)
                .findCorrectResourceLimitForDomain(Mockito.any(Domain.class), Mockito.any(Resource.ResourceType.class), Mockito.anyString());
        Long domainCount = 4L;
        Mockito.when(resourceCountVO.getCount()).thenReturn(domainCount);
        Mockito.when(resourceCountDao.findByOwnerAndTypeAndTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceOwnerType.Domain), Mockito.any(Resource.ResourceType.class),
                Mockito.anyString())).thenReturn(resourceCountVO);
        res = resourceLimitManager.getTaggedResourceLimitAndCountResponse(null,
                domain, Resource.ResourceOwnerType.Domain, Resource.ResourceType.user_vm, "tag");
        Assert.assertEquals(domainLimit, res.getLimit());
        Assert.assertEquals(domainCount, res.getTotal());
        available = domainLimit - domainCount;
        Assert.assertEquals(available, res.getAvailable());
    }

    @Test
    public void testUpdateTaggedResourceLimitsAndCountsForAccounts() {
        String tag = "tag";
        resourceLimitManager.updateTaggedResourceLimitsAndCountsForAccounts(
                List.of(Mockito.mock(AccountResponse.class)), "tag");
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .updateTaggedResourceLimitsAndCountsForAccountsOrDomains(Mockito.anyList(),
                        Mockito.eq(null), Mockito.eq(tag));
    }

    @Test
    public void updateTaggedResourceLimitsAndCountsForDomains() {
        String tag = "tag";
        resourceLimitManager.updateTaggedResourceLimitsAndCountsForDomains(
                List.of(Mockito.mock(DomainResponse.class)), "tag");
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .updateTaggedResourceLimitsAndCountsForAccountsOrDomains(Mockito.eq(null),
                        Mockito.anyList(), Mockito.eq(tag));
    }

    private void mockCheckResourceLimitWithTag() throws ResourceAllocationException {
        Mockito.doNothing().when(resourceLimitManager).checkResourceLimitWithTag(
                Mockito.any(Account.class), Mockito.any(Resource.ResourceType.class), Mockito.anyString());
        Mockito.doNothing().when(resourceLimitManager).checkResourceLimitWithTag(
                Mockito.any(Account.class), Mockito.any(Resource.ResourceType.class), Mockito.anyString(), Mockito.anyLong());
    }

    private void mockIncrementResourceCountWithTag() {
        Mockito.doNothing().when(resourceLimitManager).incrementResourceCountWithTag(
                Mockito.anyLong(), Mockito.any(Resource.ResourceType.class), Mockito.anyString());
        Mockito.doNothing().when(resourceLimitManager).incrementResourceCountWithTag(
                Mockito.anyLong(), Mockito.any(Resource.ResourceType.class), Mockito.anyString(), Mockito.anyLong());
    }

    private void mockDecrementResourceCountWithTag() {
        Mockito.doNothing().when(resourceLimitManager).decrementResourceCountWithTag(
                Mockito.anyLong(), Mockito.any(Resource.ResourceType.class), Mockito.anyString());
        Mockito.doNothing().when(resourceLimitManager).decrementResourceCountWithTag(
                Mockito.anyLong(), Mockito.any(Resource.ResourceType.class), Mockito.anyString(), Mockito.anyLong());
    }

    @Test
    public void testCheckVolumeResourceCount() throws ResourceAllocationException {
        Account account = Mockito.mock(Account.class);
        String tag = "tag";
        long delta = 10L;
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager)
                .getResourceLimitStorageTagsForResourceCountOperation(Mockito.anyBoolean(), Mockito.any(DiskOffering.class));
        resourceLimitManager.incrementVolumeResourceCount(1L, false, delta, Mockito.mock(DiskOffering.class));
        Mockito.verify(resourceLimitManager, Mockito.never()).checkResourceLimitWithTag(Mockito.any(Account.class),
                Mockito.eq(Resource.ResourceType.volume), Mockito.anyString());
        Mockito.verify(resourceLimitManager, Mockito.never()).checkResourceLimitWithTag(Mockito.any(Account.class),
                Mockito.eq(Resource.ResourceType.primary_storage), Mockito.anyString(), Mockito.anyLong());

        Mockito.doReturn(List.of(tag)).when(resourceLimitManager)
                .getResourceLimitStorageTagsForResourceCountOperation(Mockito.anyBoolean(), Mockito.any(DiskOffering.class));
        mockCheckResourceLimitWithTag();
        resourceLimitManager.checkVolumeResourceLimit(account, false, delta, Mockito.mock(DiskOffering.class));
        Mockito.verify(resourceLimitManager, Mockito.times(1)).checkResourceLimitWithTag(
                account, Resource.ResourceType.volume, tag);
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .checkResourceLimitWithTag(account, Resource.ResourceType.primary_storage, tag, 10L);
    }

    @Test
    public void testIncrementVolumeResourceCount() {
        long accountId = 1L;
        String tag = "tag";
        long delta = 10L;
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager)
                .getResourceLimitStorageTagsForResourceCountOperation(Mockito.anyBoolean(), Mockito.any(DiskOffering.class));
        resourceLimitManager.incrementVolumeResourceCount(accountId, false, delta, Mockito.mock(DiskOffering.class));
        Mockito.verify(resourceLimitManager, Mockito.never()).incrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.volume), Mockito.anyString());
        Mockito.verify(resourceLimitManager, Mockito.never()).incrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.primary_storage), Mockito.anyString(), Mockito.anyLong());

        Mockito.doReturn(List.of(tag)).when(resourceLimitManager)
                .getResourceLimitStorageTagsForResourceCountOperation(Mockito.anyBoolean(), Mockito.any(DiskOffering.class));
        mockIncrementResourceCountWithTag();
        resourceLimitManager.incrementVolumeResourceCount(accountId, false, delta, Mockito.mock(DiskOffering.class));
        Mockito.verify(resourceLimitManager, Mockito.times(1)).incrementResourceCountWithTag(
                1L, Resource.ResourceType.volume, tag);
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .incrementResourceCountWithTag(accountId, Resource.ResourceType.primary_storage, tag, delta);
    }

    @Test
    public void testDecrementVolumeResourceCount() {
        long accountId = 1L;
        String tag = "tag";
        long delta = 10L;
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager)
                .getResourceLimitStorageTagsForResourceCountOperation(Mockito.anyBoolean(), Mockito.any(DiskOffering.class));
        resourceLimitManager.decrementVolumeResourceCount(accountId, false, delta, Mockito.mock(DiskOffering.class));
        Mockito.verify(resourceLimitManager, Mockito.never()).decrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.volume), Mockito.anyString());
        Mockito.verify(resourceLimitManager, Mockito.never()).decrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.primary_storage), Mockito.anyString(), Mockito.anyLong());

        Mockito.doReturn(List.of(tag)).when(resourceLimitManager)
                .getResourceLimitStorageTagsForResourceCountOperation(Mockito.anyBoolean(), Mockito.any(DiskOffering.class));
        mockDecrementResourceCountWithTag();
        resourceLimitManager.decrementVolumeResourceCount(accountId, false, delta, Mockito.mock(DiskOffering.class));
        Mockito.verify(resourceLimitManager, Mockito.times(1)).decrementResourceCountWithTag(
                1L, Resource.ResourceType.volume, tag);
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .decrementResourceCountWithTag(accountId, Resource.ResourceType.primary_storage, tag, delta);
    }

    @Test
    public void testIncrementVolumePrimaryStorageResourceCount() {
        long accountId = 1L;
        String tag = "tag";
        long delta = 10L;
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager)
                .getResourceLimitStorageTagsForResourceCountOperation(Mockito.anyBoolean(), Mockito.any(DiskOffering.class));
        resourceLimitManager.incrementVolumePrimaryStorageResourceCount(accountId, false, delta, Mockito.mock(DiskOffering.class));
        Mockito.verify(resourceLimitManager, Mockito.never()).incrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.primary_storage), Mockito.anyString(), Mockito.anyLong());

        Mockito.doReturn(List.of(tag)).when(resourceLimitManager)
                .getResourceLimitStorageTagsForResourceCountOperation(Mockito.anyBoolean(), Mockito.any(DiskOffering.class));
        mockIncrementResourceCountWithTag();
        resourceLimitManager.incrementVolumePrimaryStorageResourceCount(accountId, false, delta, Mockito.mock(DiskOffering.class));
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .incrementResourceCountWithTag(accountId, Resource.ResourceType.primary_storage, tag, delta);
    }

    @Test
    public void testDecrementVolumePrimaryStorageResourceCount() {
        long accountId = 1L;
        String tag = "tag";
        long delta = 10L;
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager)
                .getResourceLimitStorageTagsForResourceCountOperation(Mockito.anyBoolean(), Mockito.any(DiskOffering.class));
        resourceLimitManager.decrementVolumePrimaryStorageResourceCount(accountId, false, delta, Mockito.mock(DiskOffering.class));
        Mockito.verify(resourceLimitManager, Mockito.never()).decrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.primary_storage), Mockito.anyString(), Mockito.anyLong());

        Mockito.doReturn(List.of(tag)).when(resourceLimitManager)
                .getResourceLimitStorageTagsForResourceCountOperation(Mockito.anyBoolean(), Mockito.any(DiskOffering.class));
        mockDecrementResourceCountWithTag();
        resourceLimitManager.decrementVolumePrimaryStorageResourceCount(accountId, false, delta, Mockito.mock(DiskOffering.class));
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .decrementResourceCountWithTag(accountId, Resource.ResourceType.primary_storage, tag, delta);
    }

    @Test
    public void testIncrementVmResourceCount() {
        long accountId = 1L;
        String tag = "tag";
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager)
                .getResourceLimitHostTagsForResourceCountOperation(Mockito.anyBoolean(),
                        Mockito.any(ServiceOffering.class), Mockito.any(VirtualMachineTemplate.class));
        resourceLimitManager.incrementVmResourceCount(accountId, false,
                Mockito.mock(ServiceOffering.class), Mockito.mock(VirtualMachineTemplate.class));
        Mockito.verify(resourceLimitManager, Mockito.never()).incrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.user_vm), Mockito.anyString());
        Mockito.verify(resourceLimitManager, Mockito.never()).incrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.cpu), Mockito.anyString(), Mockito.anyLong());
        Mockito.verify(resourceLimitManager, Mockito.never()).incrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.memory), Mockito.anyString(), Mockito.anyLong());

        Mockito.doReturn(List.of(tag)).when(resourceLimitManager)
                .getResourceLimitHostTagsForResourceCountOperation(Mockito.anyBoolean(),
                        Mockito.any(ServiceOffering.class), Mockito.any(VirtualMachineTemplate.class));
        mockIncrementResourceCountWithTag();
        ServiceOffering offering = Mockito.mock(ServiceOffering.class);
        int cpu = 1;
        Mockito.when(offering.getCpu()).thenReturn(cpu);
        int memory = 1024;
        Mockito.when(offering.getRamSize()).thenReturn(memory);
        resourceLimitManager.incrementVmResourceCount(accountId, false,
                offering, Mockito.mock(VirtualMachineTemplate.class));
        Mockito.verify(resourceLimitManager, Mockito.times(1)).incrementResourceCountWithTag(
                1L, Resource.ResourceType.user_vm, tag);
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .incrementResourceCountWithTag(accountId, Resource.ResourceType.cpu, tag, Long.valueOf(cpu));
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .incrementResourceCountWithTag(accountId, Resource.ResourceType.memory, tag, Long.valueOf(memory));
    }

    @Test
    public void testDecrementVmResourceCount() {
        long accountId = 1L;
        String tag = "tag";
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager)
                .getResourceLimitHostTagsForResourceCountOperation(Mockito.anyBoolean(),
                        Mockito.any(ServiceOffering.class), Mockito.any(VirtualMachineTemplate.class));
        resourceLimitManager.decrementVmResourceCount(accountId, false,
                Mockito.mock(ServiceOffering.class), Mockito.mock(VirtualMachineTemplate.class));
        Mockito.verify(resourceLimitManager, Mockito.never()).decrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.user_vm), Mockito.anyString());
        Mockito.verify(resourceLimitManager, Mockito.never()).decrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.cpu), Mockito.anyString(), Mockito.anyLong());
        Mockito.verify(resourceLimitManager, Mockito.never()).decrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.memory), Mockito.anyString(), Mockito.anyLong());

        Mockito.doReturn(List.of(tag)).when(resourceLimitManager)
                .getResourceLimitHostTagsForResourceCountOperation(Mockito.anyBoolean(),
                        Mockito.any(ServiceOffering.class), Mockito.any(VirtualMachineTemplate.class));
        mockDecrementResourceCountWithTag();
        ServiceOffering offering = Mockito.mock(ServiceOffering.class);
        int cpu = 1;
        Mockito.when(offering.getCpu()).thenReturn(cpu);
        int memory = 1024;
        Mockito.when(offering.getRamSize()).thenReturn(memory);
        resourceLimitManager.decrementVmResourceCount(accountId, false,
                offering, Mockito.mock(VirtualMachineTemplate.class));
        Mockito.verify(resourceLimitManager, Mockito.times(1)).decrementResourceCountWithTag(
                1L, Resource.ResourceType.user_vm, tag);
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .decrementResourceCountWithTag(accountId, Resource.ResourceType.cpu, tag, Long.valueOf(cpu));
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .decrementResourceCountWithTag(accountId, Resource.ResourceType.memory, tag, Long.valueOf(memory));
    }

    @Test
    public void testIncrementVmCpuResourceCount() {
        long accountId = 1L;
        String tag = "tag";
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager)
                .getResourceLimitHostTagsForResourceCountOperation(Mockito.anyBoolean(),
                        Mockito.any(ServiceOffering.class), Mockito.any(VirtualMachineTemplate.class));
        resourceLimitManager.incrementVmCpuResourceCount(accountId, false,
                Mockito.mock(ServiceOffering.class), Mockito.mock(VirtualMachineTemplate.class), null);
        Mockito.verify(resourceLimitManager, Mockito.never()).incrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.cpu), Mockito.anyString(), Mockito.anyLong());

        Mockito.doReturn(List.of(tag)).when(resourceLimitManager)
                .getResourceLimitHostTagsForResourceCountOperation(Mockito.anyBoolean(),
                        Mockito.any(ServiceOffering.class), Mockito.any(VirtualMachineTemplate.class));
        mockIncrementResourceCountWithTag();
        ServiceOffering offering = Mockito.mock(ServiceOffering.class);
        Long cpu = 2L;
        resourceLimitManager.incrementVmCpuResourceCount(accountId, false,
                offering, Mockito.mock(VirtualMachineTemplate.class), cpu);
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .incrementResourceCountWithTag(accountId, Resource.ResourceType.cpu, tag, cpu);
    }

    @Test
    public void testDecrementVmCpuResourceCount() {
        long accountId = 1L;
        String tag = "tag";
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager)
                .getResourceLimitHostTagsForResourceCountOperation(Mockito.anyBoolean(),
                        Mockito.any(ServiceOffering.class), Mockito.any(VirtualMachineTemplate.class));
        resourceLimitManager.decrementVmCpuResourceCount(accountId, false,
                Mockito.mock(ServiceOffering.class), Mockito.mock(VirtualMachineTemplate.class), null);
        Mockito.verify(resourceLimitManager, Mockito.never()).decrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.cpu), Mockito.anyString(), Mockito.anyLong());

        Mockito.doReturn(List.of(tag)).when(resourceLimitManager)
                .getResourceLimitHostTagsForResourceCountOperation(Mockito.anyBoolean(),
                        Mockito.any(ServiceOffering.class), Mockito.any(VirtualMachineTemplate.class));
        mockDecrementResourceCountWithTag();
        ServiceOffering offering = Mockito.mock(ServiceOffering.class);
        int cpu = 1;
        Mockito.when(offering.getCpu()).thenReturn(cpu);
        resourceLimitManager.decrementVmCpuResourceCount(accountId, false,
                offering, Mockito.mock(VirtualMachineTemplate.class), null);
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .decrementResourceCountWithTag(accountId, Resource.ResourceType.cpu, tag, Long.valueOf(cpu));
    }

    @Test
    public void testIncrementVmMemoryResourceCount() {
        long accountId = 1L;
        String tag = "tag";
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager)
                .getResourceLimitHostTagsForResourceCountOperation(Mockito.anyBoolean(),
                        Mockito.any(ServiceOffering.class), Mockito.any(VirtualMachineTemplate.class));
        resourceLimitManager.incrementVmMemoryResourceCount(accountId, false,
                Mockito.mock(ServiceOffering.class), Mockito.mock(VirtualMachineTemplate.class), null);
        Mockito.verify(resourceLimitManager, Mockito.never()).incrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.cpu), Mockito.anyString(), Mockito.anyLong());

        Mockito.doReturn(List.of(tag)).when(resourceLimitManager)
                .getResourceLimitHostTagsForResourceCountOperation(Mockito.anyBoolean(),
                        Mockito.any(ServiceOffering.class), Mockito.any(VirtualMachineTemplate.class));
        mockIncrementResourceCountWithTag();
        ServiceOffering offering = Mockito.mock(ServiceOffering.class);
        long memory = 1024L;
        resourceLimitManager.incrementVmMemoryResourceCount(accountId, false,
                offering, Mockito.mock(VirtualMachineTemplate.class), memory);
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .incrementResourceCountWithTag(accountId, Resource.ResourceType.memory, tag, memory);
    }

    @Test
    public void testDecrementVmMemoryResourceCount() {
        long accountId = 1L;
        String tag = "tag";
        Mockito.doReturn(new ArrayList<>()).when(resourceLimitManager)
                .getResourceLimitHostTagsForResourceCountOperation(Mockito.anyBoolean(),
                        Mockito.any(ServiceOffering.class), Mockito.any(VirtualMachineTemplate.class));
        resourceLimitManager.decrementVmMemoryResourceCount(accountId, false,
                Mockito.mock(ServiceOffering.class), Mockito.mock(VirtualMachineTemplate.class), null);
        Mockito.verify(resourceLimitManager, Mockito.never()).decrementResourceCountWithTag(Mockito.anyLong(),
                Mockito.eq(Resource.ResourceType.memory), Mockito.anyString(), Mockito.anyLong());

        Mockito.doReturn(List.of(tag)).when(resourceLimitManager)
                .getResourceLimitHostTagsForResourceCountOperation(Mockito.anyBoolean(),
                        Mockito.any(ServiceOffering.class), Mockito.any(VirtualMachineTemplate.class));
        mockDecrementResourceCountWithTag();
        ServiceOffering offering = Mockito.mock(ServiceOffering.class);
        int memory = 1024;
        Mockito.when(offering.getRamSize()).thenReturn(memory);
        resourceLimitManager.decrementVmMemoryResourceCount(accountId, false,
                offering, Mockito.mock(VirtualMachineTemplate.class), null);
        Mockito.verify(resourceLimitManager, Mockito.times(1))
                .decrementResourceCountWithTag(accountId, Resource.ResourceType.memory, tag, Long.valueOf(memory));
    }
}