catalog/src/test/java/org/apache/atlas/catalog/TaxonomyResourceProviderTest.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.definition.TaxonomyResourceDefinition;
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.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 TaxonomyResourceProvider.
 */
public class TaxonomyResourceProviderTest {
    @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();

        Collection<Map<String, Object>> queryResult = new ArrayList<>();
        Map<String, Object> queryResultRow = new HashMap<>();
        queryResult.add(queryResultRow);
        queryResultRow.put("name", "taxonomyName");
        queryResultRow.put("description", "test taxonomy description");
        queryResultRow.put("creation_time", "04/20/2016");

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

        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

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

        Result result = provider.getResourceById(userRequest);

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

        Request request = requestCapture.getValue();
        assertNull(request.getQueryString());
        assertEquals(0, request.getAdditionalSelectProperties().size());
        assertEquals(requestProperties, request.getQueryProperties());

        verify(typeSystem, queryFactory, query);
    }

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

        Collection<Map<String, Object>> queryResult = new ArrayList<>();
        Map<String, Object> queryResultRow = new HashMap<>();
        queryResult.add(queryResultRow);
        queryResultRow.put("name", "taxonomyName");
        queryResultRow.put("description", "test taxonomy description");
        queryResultRow.put("creation_time", "04/20/2016");

        // mock expectations
        expect(queryFactory.createTaxonomyQuery(capture(checkForAnyTaxonomiesCapture))).andReturn(query);
        expect(query.execute()).andReturn(Collections.<Map<String, Object>>emptySet());
        expect(typeSystem.createEntity(capture(resourceDefinitionCapture), capture(createDefaultTaxonomyRequestCapture))).andReturn("testGuid");
        expect(queryFactory.createTaxonomyQuery(capture(requestCapture))).andReturn(query);
        expect(query.execute()).andReturn(queryResult);
        replay(typeSystem, queryFactory, query);

        TestTaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem);
        provider.setInitialized(false);
        provider.setQueryFactory(queryFactory);

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

        Result result = provider.getResourceById(userRequest);

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

        Request request = requestCapture.getValue();
        assertNull(request.getQueryString());
        assertEquals(0, request.getAdditionalSelectProperties().size());
        assertEquals(requestProperties, request.getQueryProperties());

        Request checkForAnyTaxonomiesRequest = checkForAnyTaxonomiesCapture.getValue();
        assertNull(checkForAnyTaxonomiesRequest.getQueryString());
        assertEquals(checkForAnyTaxonomiesRequest.getAdditionalSelectProperties().size(), 0);
        assertEquals(checkForAnyTaxonomiesRequest.getQueryProperties().size(), 0);

        Request createDefaultTaxonomyRequest = createDefaultTaxonomyRequestCapture.getValue();
        assertNull(createDefaultTaxonomyRequest.getQueryString());
        assertEquals(createDefaultTaxonomyRequest.getAdditionalSelectProperties().size(), 0);
        assertEquals(createDefaultTaxonomyRequest.getQueryProperties().size(), 2);
        assertEquals(createDefaultTaxonomyRequest.getQueryProperties().get("name"),
                TaxonomyResourceProvider.DEFAULT_TAXONOMY_NAME);
        assertEquals(createDefaultTaxonomyRequest.getQueryProperties().get("description"),
                TaxonomyResourceProvider.DEFAULT_TAXONOMY_DESCRIPTION);

        verify(typeSystem, queryFactory, query);
    }

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

        Collection<Map<String, Object>> queryResult = new ArrayList<>();
        Map<String, Object> queryResultRow = new HashMap<>();
        queryResult.add(queryResultRow);
        queryResultRow.put("name", "taxonomyName");
        queryResultRow.put("description", "test taxonomy description");
        queryResultRow.put("creation_time", "04/20/2016");

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

        TestTaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem);
        provider.setInitialized(false);
        provider.setQueryFactory(queryFactory);

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

        Result result = provider.getResourceById(userRequest);

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

        Request request = requestCapture.getValue();
        assertNull(request.getQueryString());
        assertEquals(0, request.getAdditionalSelectProperties().size());
        assertEquals(requestProperties, request.getQueryProperties());

        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.createTaxonomyQuery(capture(requestCapture))).andReturn(query);
        expect(query.execute()).andReturn(emptyResponse);
        replay(typeSystem, queryFactory, query);

        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

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

        provider.getResourceById(request);

        verify(typeSystem, queryFactory, query);
    }

    @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();

        Collection<Map<String, Object>> queryResult = new ArrayList<>();
        Map<String, Object> queryResultRow1 = new HashMap<>();
        queryResult.add(queryResultRow1);
        queryResultRow1.put("mame", "taxonomyName1");
        queryResultRow1.put("description", "test taxonomy description");
        queryResultRow1.put("creation_time", "04/20/2016");

        Map<String, Object> queryResultRow2 = new HashMap<>();
        queryResult.add(queryResultRow2);
        queryResultRow2.put("mame", "taxonomyName2");
        queryResultRow2.put("description", "test taxonomy description 2");
        queryResultRow2.put("creation_time", "04/21/2016");

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

        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

        Request userRequest = new CollectionRequest(Collections.<String, Object>emptyMap(), "name:taxonomy*");
        Result result = provider.getResources(userRequest);

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

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

        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();

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

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

        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

        Request userRequest = new CollectionRequest(Collections.<String, Object>emptyMap(), "name:taxonomy*");
        Result result = provider.getResources(userRequest);

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

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

        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);

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

        // taxonomy create request must contain 'name' property
        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("description", "test");
        Request userRequest = new InstanceRequest(requestProperties);

        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

        provider.createResource(userRequest);
    }

    @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<Request> requestCapture = newCapture();

        // query is executed to see if resource already exists
        Collection<Map<String, Object>> queryResult = new ArrayList<>();
        Map<String, Object> queryResultRow = new HashMap<>();
        queryResult.add(queryResultRow);
        queryResultRow.put("mame", "taxonomyName");
        queryResultRow.put("description", "test taxonomy description");
        queryResultRow.put("creation_time", "04/20/2016");

        // mock expectations
        expect(queryFactory.createTaxonomyQuery(capture(requestCapture))).andReturn(query);
        // returning result for query should result in ResourceAlreadyExistsException
        expect(query.execute()).andReturn(queryResult);
        replay(typeSystem, queryFactory, query);

        // taxonomy create request must contain 'name' property
        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("name", "taxonomyName");
        Request userRequest = new InstanceRequest(requestProperties);

        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(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();
        Capture<Request> requestCapture = newCapture();

        // empty response indicates that resource doesn't already exist
        Collection<Map<String, Object>> queryResult = new ArrayList<>();

        // mock expectations
        expect(queryFactory.createTaxonomyQuery(capture(requestCapture))).andReturn(query);
        expect(query.execute()).andReturn(queryResult);
        expect(typeSystem.createEntity(capture(resourceDefinitionCapture), capture(requestCapture))).andReturn("testGuid");
        replay(typeSystem, queryFactory, query);

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

        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

        provider.createResource(userRequest);

        assertEquals(new TaxonomyResourceDefinition().getTypeName(),
                resourceDefinitionCapture.getValue().getTypeName());

        Request request = requestCapture.getValue();
        assertNull(request.getQueryString());
        assertEquals(requestProperties, request.getQueryProperties());

        verify(typeSystem, queryFactory, query);
    }

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

        // mock expectations
        replay(typeSystem, queryFactory);

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

        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);

        provider.createResources(userRequest);
    }

    @Test
    public void testDeleteResourceById() throws Exception {
        TermResourceProvider termResourceProvider = createStrictMock(TermResourceProvider.class);
        AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class);
        QueryFactory queryFactory = createStrictMock(QueryFactory.class);
        AtlasQuery query = createStrictMock(AtlasQuery.class);
        Capture<Request> getRequestCapture = newCapture();
        Capture<TermPath> termPathCapture = newCapture();
        Capture<ResourceDefinition> resourceDefinitionCapture = newCapture();
        Capture<Request> deleteRequestCapture = newCapture();

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

        // mock expectations
        expect(queryFactory.createTaxonomyQuery(capture(getRequestCapture))).andReturn(query);
        expect(query.execute()).andReturn(queryResult);
        termResourceProvider.deleteChildren(eq("111-222-333"), capture(termPathCapture));
        typeSystem.deleteEntity(capture(resourceDefinitionCapture), capture(deleteRequestCapture));
        replay(termResourceProvider, typeSystem, queryFactory, query);

        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem, termResourceProvider);
        provider.setQueryFactory(queryFactory);

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

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

        Request getRequest = getRequestCapture.getValue();
        assertNull(getRequest.getQueryString());
        assertEquals(getRequest.getAdditionalSelectProperties().size(), 1);
        assertTrue(getRequest.getAdditionalSelectProperties().contains("id"));
        assertEquals(getRequest.getQueryProperties().get("name"), "testTaxonomy");

        Request deleteRequest = deleteRequestCapture.getValue();
        assertNull(deleteRequest.getQueryString());
        assertEquals(deleteRequest.getAdditionalSelectProperties().size(), 1);
        assertTrue(deleteRequest.getAdditionalSelectProperties().contains("id"));
        assertEquals(deleteRequest.getQueryProperties().get("name"), "testTaxonomy");

        ResourceDefinition resourceDefinition = resourceDefinitionCapture.getValue();
        assertTrue(resourceDefinition instanceof TaxonomyResourceDefinition);

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

    @Test(expectedExceptions = ResourceNotFoundException.class)
    public void testDeleteResourceById_404() throws Exception {
        AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class);
        QueryFactory queryFactory = createStrictMock(QueryFactory.class);
        AtlasQuery query = createStrictMock(AtlasQuery.class);
        Capture<Request> getRequestCapture = newCapture();
        // mock expectations
        expect(queryFactory.createTaxonomyQuery(capture(getRequestCapture))).andReturn(query);
        expect(query.execute()).andThrow(new ResourceNotFoundException("test msg"));

        replay(typeSystem, queryFactory, query);

        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem, null);
        provider.setQueryFactory(queryFactory);

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

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

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

        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("name", "testTaxonomy");
        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");

        // mock expectations
        // term update
        expect(queryFactory.createTaxonomyQuery(capture(taxonomyRequestCapture))).andReturn(query);
        expect(query.execute(requestUpdateProperties)).andReturn(queryResult);
        replay(typeSystem, queryFactory, query);

        // instantiate resource provider and invoke method being tested
        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);
        provider.updateResourceById(userRequest);

        Request request = taxonomyRequestCapture.getValue();
        assertNull(request.getQueryString());
        assertEquals(request.getQueryProperties().size(), 1);
        assertEquals(request.getQueryProperties().get("name"), "testTaxonomy");
        assertEquals(request.getUpdateProperties().size(), 1);
        assertEquals(request.getUpdateProperties().get("description"), "updatedValue");

        verify(typeSystem, queryFactory, query);
    }

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

        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("name", "testTaxonomy");
        Map<String, Object> requestUpdateProperties = new HashMap<>();
        requestUpdateProperties.put("name", "notCurrentlySupported");
        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");

        // mock expectations
        // term update
        expect(queryFactory.createTaxonomyQuery(capture(taxonomyRequestCapture))).andReturn(query);
        expect(query.execute(requestUpdateProperties)).andReturn(queryResult);
        replay(typeSystem, queryFactory, query);

        // instantiate resource provider and invoke method being tested
        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);
        provider.updateResourceById(userRequest);

        verify(typeSystem, queryFactory, query);
    }

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

        Map<String, Object> requestProperties = new HashMap<>();
        requestProperties.put("name", "testTaxonomy");
        Map<String, Object> requestUpdateProperties = new HashMap<>();
        requestUpdateProperties.put("description", "updated");
        Request userRequest = new InstanceRequest(requestProperties, requestUpdateProperties);
        // mock expectations
        // term update
        expect(queryFactory.createTaxonomyQuery(capture(taxonomyRequestCapture))).andReturn(query);
        expect(query.execute(requestUpdateProperties)).andReturn(Collections.<Map<String, Object>>emptyList());
        replay(typeSystem, queryFactory, query);

        // instantiate resource provider and invoke method being tested
        TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem);
        provider.setQueryFactory(queryFactory);
        provider.updateResourceById(userRequest);

        verify(typeSystem, queryFactory, query);
    }

    private static class TestTaxonomyResourceProvider extends TaxonomyResourceProvider {
        private final TermResourceProvider termResourceProvider;
        private boolean isInitialized = true;

        public TestTaxonomyResourceProvider(AtlasTypeSystem typeSystem) {
            super(typeSystem);
            this.termResourceProvider = null;
        }

        public TestTaxonomyResourceProvider(AtlasTypeSystem typeSystem, TermResourceProvider termResourceProvider) {
            super(typeSystem);
            this.termResourceProvider = termResourceProvider;
        }

        public void setInitialized(boolean isInitialized) {
            this.isInitialized = isInitialized;
        }

        @Override
        protected synchronized TermResourceProvider getTermResourceProvider() {
            return termResourceProvider;
        }

        @Override
        protected boolean autoInitializationChecked() {
            return isInitialized;
        }
    }
}