catalog/src/test/java/org/apache/atlas/catalog/TermResourceProviderTest.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
 * <p/>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p/>
 * 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.atlas.catalog;

import org.apache.atlas.catalog.definition.ResourceDefinition;
import org.apache.atlas.catalog.exception.InvalidPayloadException;
import org.apache.atlas.catalog.exception.ResourceAlreadyExistsException;
import org.apache.atlas.catalog.exception.ResourceNotFoundException;
import org.apache.atlas.catalog.query.AtlasQuery;
import org.apache.atlas.catalog.query.QueryFactory;
import org.easymock.Capture;
import org.easymock.EasyMock;
import org.testng.annotations.Test;

import java.util.*;

import static org.easymock.EasyMock.*;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertTrue;

/**
 * Unit tests for TermResourceProvider.
 */
public class TermResourceProviderTest {
    @Test
    public void testGetResourceById() throws Exception {
        AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class);
        QueryFactory queryFactory = createStrictMock(QueryFactory.class);
        AtlasQuery query = createStrictMock(AtlasQuery.class);
        Capture<Request> requestCapture = newCapture();

        TermPath termPath = new TermPath("testTaxonomy", "termName");

        Collection<Map<String, Object>> queryResult = new ArrayList<>();
        Map<String, Object> queryResultRow = new HashMap<>();
        queryResult.add(queryResultRow);
        queryResultRow.put("name", "testTaxonomy.termName");
        queryResultRow.put("description", "test term description");
        queryResultRow.put("creation_time", "04/20/2016");
        queryResultRow.put("acceptable_use", "anything");
        queryResultRow.put("available_as_tag", true);
        Map<String, Object> hierarchyMap = new HashMap<>();
        queryResultRow.put("hierarchy", hierarchyMap);
        hierarchyMap.put("path", "/");
        hierarchyMap.put("short_name", "termName");
        hierarchyMap.put("taxonomy", "testTaxonomy");

        // mock expectations
        expect(queryFactory.createTermQuery(capture(requestCapture))).andReturn(query);
        expect(query.execute()).andReturn(queryResult);
        replay(typeSystem, queryFactory, query);

        TermResourceProvider provider = new TermResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("termPath", termPath);
        Request userRequest = new InstanceRequest(requestProperties);

        Result result = provider.getResourceById(userRequest);

        assertEquals(result.getPropertyMaps().size(), 1);
        assertEquals(result.getPropertyMaps().iterator().next(), queryResultRow);

        Request request = requestCapture.getValue();
        assertNull(request.getQueryString());
        assertEquals(request.getAdditionalSelectProperties().size(), 0);
        assertEquals(request.getQueryProperties().size(), 2);
        assertEquals(request.getQueryProperties().get("termPath"), termPath);
        assertEquals(request.getQueryProperties().get("name"), termPath.getFullyQualifiedName());

        verify(typeSystem, queryFactory, query);
    }

    @Test(expectedExceptions = ResourceNotFoundException.class)
    public void testGetResourceById_404() throws Exception {
        AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class);
        QueryFactory queryFactory = createStrictMock(QueryFactory.class);
        AtlasQuery query = createStrictMock(AtlasQuery.class);
        Capture<Request> requestCapture = newCapture();

        // empty response should result in a ResourceNotFoundException
        Collection<Map<String, Object>> emptyResponse = new ArrayList<>();

        // mock expectations
        expect(queryFactory.createTermQuery(capture(requestCapture))).andReturn(query);
        expect(query.execute()).andReturn(emptyResponse);
        replay(typeSystem, queryFactory, query);

        TermResourceProvider provider = new TermResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("termPath", new TermPath("taxonomyName.badTermName"));
        Request request = new InstanceRequest(requestProperties);

        provider.getResourceById(request);
    }

    @Test
    public void testGetResources() throws Exception {
        AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class);
        QueryFactory queryFactory = createStrictMock(QueryFactory.class);
        AtlasQuery query = createStrictMock(AtlasQuery.class);
        Capture<Request> requestCapture = newCapture();

        TermPath termPath = new TermPath("testTaxonomy", null);

        Collection<Map<String, Object>> queryResult = new ArrayList<>();
        Map<String, Object> queryResultRow1 = new HashMap<>();
        queryResult.add(queryResultRow1);
        queryResultRow1.put("name", "testTaxonomy.termName");
        queryResultRow1.put("description", "test term description");
        queryResultRow1.put("creation_time", "04/20/2016");
        queryResultRow1.put("acceptable_use", "anything");
        queryResultRow1.put("available_as_tag", true);
        Map<String, Object> hierarchyMap = new HashMap<>();
        queryResultRow1.put("hierarchy", hierarchyMap);
        hierarchyMap.put("path", "/");
        hierarchyMap.put("short_name", "termName");
        hierarchyMap.put("taxonomy", "testTaxonomy");

        Map<String, Object> queryResultRow2 = new HashMap<>();
        queryResult.add(queryResultRow2);
        queryResultRow2.put("name", "testTaxonomy.termName2");
        queryResultRow2.put("description", "test term 2 description");
        queryResultRow2.put("creation_time", "04/21/2016");
        queryResultRow2.put("acceptable_use", "anything");
        queryResultRow2.put("available_as_tag", true);
        Map<String, Object> hierarchyMap2 = new HashMap<>();
        queryResultRow2.put("hierarchy", hierarchyMap2);
        hierarchyMap2.put("path", "/");
        hierarchyMap2.put("short_name", "termName2");
        hierarchyMap2.put("taxonomy", "testTaxonomy");

        // mock expectations
        expect(queryFactory.createTermQuery(capture(requestCapture))).andReturn(query);
        expect(query.execute()).andReturn(queryResult);
        replay(typeSystem, queryFactory, query);

        TermResourceProvider provider = new TermResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("termPath", termPath);
        Request userRequest = new CollectionRequest(requestProperties, "name:taxonomy*");
        // invoke test method
        Result result = provider.getResources(userRequest);

        assertEquals(result.getPropertyMaps().size(), 2);
        assertTrue(result.getPropertyMaps().contains(queryResultRow1));
        assertTrue(result.getPropertyMaps().contains(queryResultRow2));

        Request request = requestCapture.getValue();
        assertEquals(request.getQueryString(), "name:taxonomy*");
        assertEquals(request.getAdditionalSelectProperties().size(), 0);
        assertEquals(request.getQueryProperties().size(), 1);

        verify(typeSystem, queryFactory, query);
    }

    @Test
    public void testGetResources_noResults() throws Exception {
        AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class);
        QueryFactory queryFactory = createStrictMock(QueryFactory.class);
        AtlasQuery query = createStrictMock(AtlasQuery.class);
        Capture<Request> requestCapture = newCapture();

        TermPath termPath = new TermPath("testTaxonomy", "termName");

        // empty result shouldn't result in exception for collection query
        Collection<Map<String, Object>> queryResult = new ArrayList<>();

        // mock expectations
        expect(queryFactory.createTermQuery(capture(requestCapture))).andReturn(query);
        expect(query.execute()).andReturn(queryResult);
        replay(typeSystem, queryFactory, query);

        TermResourceProvider provider = new TermResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("termPath", termPath);
        Request userRequest = new CollectionRequest(requestProperties, "name:taxonomy*");
        // invoke test method
        Result result = provider.getResources(userRequest);

        assertEquals(0, result.getPropertyMaps().size());

        Request request = requestCapture.getValue();
        assertEquals(request.getQueryString(), "name:taxonomy*");
        assertEquals(request.getAdditionalSelectProperties().size(), 0);
        assertEquals(request.getQueryProperties().size(), 1);

        verify(typeSystem, queryFactory, query);
    }

    @Test(expectedExceptions = InvalidPayloadException.class)
    public void testCreateResource_invalidRequest__noName() throws Exception {
        AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class);
        QueryFactory queryFactory = createStrictMock(QueryFactory.class);
        AtlasQuery query = createStrictMock(AtlasQuery.class);

        // null term name should result in InvalidPayloadException
        TermPath termPath = new TermPath("testTaxonomy", null);

        // mock expectations
        replay(typeSystem, queryFactory, query);

        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("termPath", termPath);
        Request userRequest = new InstanceRequest(requestProperties);

        TermResourceProvider provider = new TermResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

        provider.createResource(userRequest);
    }

    @Test
    public void testCreateResource() throws Exception {
        AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class);
        QueryFactory queryFactory = createStrictMock(QueryFactory.class);
        AtlasQuery query = createStrictMock(AtlasQuery.class);
        Capture<ResourceDefinition> resourceDefinitionCapture = newCapture();
        ResourceProvider taxonomyResourceProvider = createStrictMock(TaxonomyResourceProvider.class);
        Capture<Request> taxonomyRequestCapture = newCapture();

        Collection<Map<String, Object>> taxonomyQueryResult = new ArrayList<>();
        Map<String, Object> taxonomyQueryResultRow = new HashMap<>();
        taxonomyQueryResult.add(taxonomyQueryResultRow);
        taxonomyQueryResultRow.put("name", "testTaxonomy");
        taxonomyQueryResultRow.put("id", "11-22-33");
        Result taxonomyResult = new Result(taxonomyQueryResult);

        Map<String, Object> expectedRequestProps = new HashMap<>();
        expectedRequestProps.put("name", "testTaxonomy.termName");
        // when not specified, the default value of 'true' should be set
        expectedRequestProps.put("available_as_tag", true);

        // mock expectations
        expect(taxonomyResourceProvider.getResourceById(capture(taxonomyRequestCapture))).andReturn(taxonomyResult);
        typeSystem.createTraitType(capture(resourceDefinitionCapture), eq("testTaxonomy.termName"), EasyMock.<String>isNull());
        typeSystem.createTraitInstance("11-22-33", "testTaxonomy.termName", expectedRequestProps);
        replay(typeSystem, queryFactory, query, taxonomyResourceProvider);

        TermResourceProvider provider = new TestTermResourceProvider(typeSystem, taxonomyResourceProvider);
        provider.setQueryFactory(queryFactory);

        TermPath termPath = new TermPath("testTaxonomy", "termName");
        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("termPath", termPath);
        Request userRequest = new InstanceRequest(requestProperties);

        provider.createResource(userRequest);

        Request taxonomyRequest = taxonomyRequestCapture.getValue();
        Map<String, Object> taxonomyRequestProps = taxonomyRequest.getQueryProperties();
        assertEquals(taxonomyRequestProps.size(), 1);
        assertEquals(taxonomyRequestProps.get("name"), "testTaxonomy");
        assertEquals(taxonomyRequest.getAdditionalSelectProperties().size(), 1);
        assertEquals(taxonomyRequest.getAdditionalSelectProperties().iterator().next(), "id");
        assertNull(taxonomyRequest.getQueryString());

        ResourceDefinition resourceDefinition = resourceDefinitionCapture.getValue();
        assertEquals(resourceDefinition.getTypeName(), "Term");

        verify(typeSystem, queryFactory, query, taxonomyResourceProvider);
    }

    @Test(expectedExceptions = ResourceAlreadyExistsException.class)
    public void testCreateResource_invalidRequest__alreadyExists() throws Exception {
        AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class);
        QueryFactory queryFactory = createStrictMock(QueryFactory.class);
        AtlasQuery query = createStrictMock(AtlasQuery.class);
        Capture<ResourceDefinition> resourceDefinitionCapture = newCapture();
        ResourceProvider taxonomyResourceProvider = createStrictMock(TaxonomyResourceProvider.class);
        Capture<Request> taxonomyRequestCapture = newCapture();

        Collection<Map<String, Object>> taxonomyQueryResult = new ArrayList<>();
        Map<String, Object> taxonomyQueryResultRow = new HashMap<>();
        taxonomyQueryResult.add(taxonomyQueryResultRow);
        taxonomyQueryResultRow.put("name", "testTaxonomy");
        taxonomyQueryResultRow.put("id", "11-22-33");
        Result taxonomyResult = new Result(taxonomyQueryResult);

        // mock expectations
        expect(taxonomyResourceProvider.getResourceById(capture(taxonomyRequestCapture))).andReturn(taxonomyResult);
        typeSystem.createTraitType(capture(resourceDefinitionCapture), eq("testTaxonomy.termName"), EasyMock.<String>isNull());
        expectLastCall().andThrow(new ResourceAlreadyExistsException(""));

        replay(typeSystem, queryFactory, query, taxonomyResourceProvider);

        TermResourceProvider provider = new TestTermResourceProvider(typeSystem, taxonomyResourceProvider);
        provider.setQueryFactory(queryFactory);

        TermPath termPath = new TermPath("testTaxonomy", "termName");
        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("termPath", termPath);
        Request userRequest = new InstanceRequest(requestProperties);

        provider.createResource(userRequest);
    }

    @Test(expectedExceptions = UnsupportedOperationException.class)
    public void testCreateResources() throws Exception {
        AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class);
        QueryFactory queryFactory = createStrictMock(QueryFactory.class);

        // mock expectations
        replay(typeSystem, queryFactory);

        TermPath termPath = new TermPath("testTaxonomy", "termName");
        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("termPath", termPath);
        Request userRequest = new InstanceRequest(requestProperties);

        TermResourceProvider provider = new TermResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

        provider.createResources(userRequest);
    }

    @Test
    public void testDeleteResourceById() throws Exception {
        ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
        ResourceProvider entityResourceProvider = createStrictMock(ResourceProvider.class);
        ResourceProvider entityTagResourceProvider = createStrictMock(ResourceProvider.class);
        AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class);
        QueryFactory queryFactory = createStrictMock(QueryFactory.class);
        AtlasQuery query = createStrictMock(AtlasQuery.class);
        Capture<Request> taxonomyRequestCapture = newCapture();
        Capture<Request> termRequestCapture = newCapture();

        // root term being deleted
        TermPath termPath = new TermPath("testTaxonomy.termName");

        // entity requests to get id's of entities tagged with terms
        Request entityRequest1 = new CollectionRequest(Collections.<String, Object>emptyMap(),
                "tags/name:testTaxonomy.termName.child1");
        Request entityRequest2 = new CollectionRequest(Collections.<String, Object>emptyMap(),
                "tags/name:testTaxonomy.termName.child2");
        Request entityRequest3 = new CollectionRequest(Collections.<String, Object>emptyMap(),
                "tags/name:testTaxonomy.termName");

        // entity tag requests to delete entity tags
        Map<String, Object> entityTagRequestMap1 = new HashMap<>();
        entityTagRequestMap1.put("id", "111");
        entityTagRequestMap1.put("name", "testTaxonomy.termName.child1");
        Request entityTagRequest1 = new InstanceRequest(entityTagRequestMap1);
        Map<String, Object> entityTagRequestMap2 = new HashMap<>();
        entityTagRequestMap2.put("id", "222");
        entityTagRequestMap2.put("name", "testTaxonomy.termName.child1");
        Request entityTagRequest2 = new InstanceRequest(entityTagRequestMap2);
        Map<String, Object> entityTagRequestMap3 = new HashMap<>();
        entityTagRequestMap3.put("id", "333");
        entityTagRequestMap3.put("name", "testTaxonomy.termName.child2");
        Request entityTagRequest3 = new InstanceRequest(entityTagRequestMap3);

        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("termPath", termPath);
        Request userRequest = new InstanceRequest(requestProperties);

        Collection<Map<String, Object>> queryResult = new ArrayList<>();
        Map<String, Object> queryResultRow = new HashMap<>();
        queryResult.add(queryResultRow);
        queryResultRow.put("name", "testTaxonomy.termName");
        queryResultRow.put("id", "111-222-333");

        Collection<Map<String, Object>> taxonomyResultMaps = new ArrayList<>();
        Map<String, Object> taxonomyResultMap = new HashMap<>();
        taxonomyResultMap.put("name", "testTaxonomy");
        taxonomyResultMap.put("id", "12345");
        taxonomyResultMaps.add(taxonomyResultMap);
        Result taxonomyResult = new Result(taxonomyResultMaps);

        Collection<Map<String, Object>> childResult = new ArrayList<>();
        Map<String, Object> childResultRow = new HashMap<>();
        childResult.add(childResultRow);
        childResultRow.put("name", "testTaxonomy.termName.child1");
        childResultRow.put("id", "1-1-1");
        Map<String, Object> childResultRow2 = new HashMap<>();
        childResult.add(childResultRow2);
        childResultRow2.put("name", "testTaxonomy.termName.child2");
        childResultRow2.put("id", "2-2-2");

        Collection<Map<String, Object>> entityResults1 = new ArrayList<>();
        Map<String, Object> entityResult1Map1 = new HashMap<>();
        entityResult1Map1.put("name", "entity1");
        entityResult1Map1.put("id", "111");
        entityResults1.add(entityResult1Map1);
        Map<String, Object> entityResult1Map2 = new HashMap<>();
        entityResult1Map2.put("name", "entity2");
        entityResult1Map2.put("id", "222");
        entityResults1.add(entityResult1Map2);
        Result entityResult1 = new Result(entityResults1);

        Collection<Map<String, Object>> entityResults2 = new ArrayList<>();
        Map<String, Object> entityResult2Map = new HashMap<>();
        entityResult2Map.put("name", "entity3");
        entityResult2Map.put("id", "333");
        entityResults2.add(entityResult2Map);
        Result entityResult2 = new Result(entityResults2);

        // mock expectations
        // ensure term exists
        expect(queryFactory.createTermQuery(userRequest)).andReturn(query);
        expect(query.execute()).andReturn(queryResult);
        // taxonomy query
        expect(taxonomyResourceProvider.getResourceById(capture(taxonomyRequestCapture))).andReturn(taxonomyResult);
        // get term children
        expect(queryFactory.createTermQuery(capture(termRequestCapture))).andReturn(query);
        expect(query.execute()).andReturn(childResult);
        // entities with child1 tag
        expect(entityResourceProvider.getResources(eq(entityRequest1))).andReturn(entityResult1);
//        typeSystem.deleteTag("111", "testTaxonomy.termName.child1");
//        typeSystem.deleteTag("222", "testTaxonomy.termName.child1");
        entityTagResourceProvider.deleteResourceById(entityTagRequest1);
        entityTagResourceProvider.deleteResourceById(entityTagRequest2);
        // delete child1 from taxonomy
        typeSystem.deleteTag("12345", "testTaxonomy.termName.child1");
        // entities with child2 tag
        expect(entityResourceProvider.getResources(eq(entityRequest2))).andReturn(entityResult2);
        //typeSystem.deleteTag("333", "testTaxonomy.termName.child2");
        entityTagResourceProvider.deleteResourceById(entityTagRequest3);
        // delete child2 from taxonomy
        typeSystem.deleteTag("12345", "testTaxonomy.termName.child2");
        // root term being deleted which has no associated tags
        expect(entityResourceProvider.getResources(eq(entityRequest3))).andReturn(
                new Result(Collections.<Map<String, Object>>emptyList()));
        // delete root term from taxonomy
        typeSystem.deleteTag("12345", "testTaxonomy.termName");

        replay(taxonomyResourceProvider, entityResourceProvider, entityTagResourceProvider, typeSystem, queryFactory, query);

        TermResourceProvider provider = new TestTermResourceProvider(
                typeSystem, taxonomyResourceProvider, entityResourceProvider, entityTagResourceProvider);
        provider.setQueryFactory(queryFactory);

        // invoke method being tested
        provider.deleteResourceById(userRequest);

        Request taxonomyRequest = taxonomyRequestCapture.getValue();
        assertEquals(taxonomyRequest.getQueryProperties().get("name"), "testTaxonomy");
        assertEquals(taxonomyRequest.getAdditionalSelectProperties().size(), 1);
        assertTrue(taxonomyRequest.getAdditionalSelectProperties().contains("id"));

        Request childTermRequest = termRequestCapture.getValue();
        assertEquals(childTermRequest.<TermPath>getProperty("termPath").getFullyQualifiedName(), "testTaxonomy.termName.");
        verify(taxonomyResourceProvider, entityResourceProvider, entityTagResourceProvider, typeSystem, queryFactory, query);
    }

    @Test
    public void testUpdateResourceById() throws Exception {
        AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class);
        QueryFactory queryFactory = createStrictMock(QueryFactory.class);
        AtlasQuery query = createStrictMock(AtlasQuery.class);
        Capture<Request> termRequestCapture = newCapture();
        Capture<Request> tagRequestCapture = newCapture();

        TermPath termPath = new TermPath("testTaxonomy", "termName");

        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("termPath", termPath);
        Map<String, Object> requestUpdateProperties = new HashMap<>();
        requestUpdateProperties.put("description", "updatedValue");
        Request userRequest = new InstanceRequest(requestProperties, requestUpdateProperties);

        Collection<Map<String, Object>> queryResult = new ArrayList<>();
        Map<String, Object> queryResultRow = new HashMap<>();
        queryResult.add(queryResultRow);
        queryResultRow.put("name", "testTaxonomy.termName");

        // mock expectations
        // term update
        expect(queryFactory.createTermQuery(capture(termRequestCapture))).andReturn(query);
        expect(query.execute(requestUpdateProperties)).andReturn(queryResult);
        // tag updates
        expect(queryFactory.createEntityTagQuery(capture(tagRequestCapture))).andReturn(query);
        // query response isn't used so just returning null
        expect(query.execute(requestUpdateProperties)).andReturn(null);
        replay(typeSystem, queryFactory, query);

        TermResourceProvider provider = new TermResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

        provider.updateResourceById(userRequest);

        Request request = termRequestCapture.getValue();
        assertNull(request.getQueryString());
        assertTrue(request.getAdditionalSelectProperties().isEmpty());
        assertEquals(request.getQueryProperties().size(), 2);
        assertEquals(request.getQueryProperties().get("termPath"), termPath);
        assertEquals(request.getQueryProperties().get("name"), termPath.getFullyQualifiedName());

        Request tagRequest = tagRequestCapture.getValue();
        assertEquals(tagRequest.getQueryString(), "name:testTaxonomy.termName");
        assertEquals(tagRequest.getQueryProperties().size(), 1);
        assertEquals(tagRequest.getQueryProperties().get("id"), "*");

        verify(typeSystem, queryFactory, query);
    }

    private static class TestTermResourceProvider extends TermResourceProvider {

        private ResourceProvider testTaxonomyResourceProvider;
        private ResourceProvider testEntityResourceProvider;
        private ResourceProvider testEntityTagResourceProvider;

        public TestTermResourceProvider(AtlasTypeSystem typeSystem,
                                        ResourceProvider taxonomyResourceProvider) {
            super(typeSystem);
            testTaxonomyResourceProvider = taxonomyResourceProvider;
        }

        public TestTermResourceProvider(AtlasTypeSystem typeSystem,
                                        ResourceProvider taxonomyResourceProvider,
                                        ResourceProvider entityResourceProvider,
                                        ResourceProvider entityTagResourceProvider) {
            super(typeSystem);
            testTaxonomyResourceProvider = taxonomyResourceProvider;
            testEntityResourceProvider = entityResourceProvider;
            testEntityTagResourceProvider = entityTagResourceProvider;
        }

        @Override
        protected synchronized ResourceProvider getTaxonomyResourceProvider() {
            return testTaxonomyResourceProvider;
        }

        @Override
        protected synchronized ResourceProvider getEntityResourceProvider() {
            return testEntityResourceProvider;
        }

        @Override
        protected synchronized ResourceProvider getEntityTagResourceProvider() {
            return testEntityTagResourceProvider;
        }
    }
}