/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.nifi.registry.db;

import org.apache.nifi.registry.db.entity.BucketEntity;
import org.apache.nifi.registry.db.entity.BucketItemEntity;
import org.apache.nifi.registry.db.entity.BucketItemEntityType;
import org.apache.nifi.registry.db.entity.ExtensionBundleEntity;
import org.apache.nifi.registry.db.entity.ExtensionBundleEntityType;
import org.apache.nifi.registry.db.entity.ExtensionBundleVersionDependencyEntity;
import org.apache.nifi.registry.db.entity.ExtensionBundleVersionEntity;
import org.apache.nifi.registry.db.entity.ExtensionEntity;
import org.apache.nifi.registry.db.entity.ExtensionEntityCategory;
import org.apache.nifi.registry.db.entity.FlowEntity;
import org.apache.nifi.registry.db.entity.FlowSnapshotEntity;
import org.apache.nifi.registry.extension.filter.ExtensionBundleFilterParams;
import org.apache.nifi.registry.extension.filter.ExtensionBundleVersionFilterParams;
import org.apache.nifi.registry.service.MetadataService;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

public class TestDatabaseMetadataService extends DatabaseBaseTest {

    @Autowired
    private MetadataService metadataService;

    //----------------- Buckets ---------------------------------

    @Test
    public void testCreateAndGetBucket() {
        final BucketEntity b = new BucketEntity();
        b.setId("testBucketId");
        b.setName("testBucketName");
        b.setDescription("testBucketDesc");
        b.setCreated(new Date());

        metadataService.createBucket(b);

        final BucketEntity createdBucket = metadataService.getBucketById(b.getId());
        assertNotNull(createdBucket);
        assertEquals(b.getId(), createdBucket.getId());
        assertEquals(b.getName(), createdBucket.getName());
        assertEquals(b.getDescription(), createdBucket.getDescription());
        assertEquals(b.getCreated(), createdBucket.getCreated());
        assertFalse(b.isAllowExtensionBundleRedeploy());
    }

    @Test
    public void testGetBucketDoesNotExist() {
        final BucketEntity bucket = metadataService.getBucketById("does-not-exist");
        assertNull(bucket);
    }

    @Test
    public void testGetBucketsByName() {
        final List<BucketEntity> buckets = metadataService.getBucketsByName("Bucket 1");
        assertNotNull(buckets);
        assertEquals(1, buckets.size());
        assertEquals("Bucket 1", buckets.get(0).getName());
    }

    @Test
    public void testGetBucketsByNameNoneFound() {
        final List<BucketEntity> buckets = metadataService.getBucketsByName("Bucket XYZ");
        assertNotNull(buckets);
        assertEquals(0, buckets.size());
    }

    @Test
    public void testUpdateBucket() {
        final BucketEntity bucket = metadataService.getBucketById("1");
        assertNotNull(bucket);
        assertFalse(bucket.isAllowExtensionBundleRedeploy());

        final String updatedName = bucket.getName() + " UPDATED";
        final String updatedDesc = bucket.getDescription() + "DESC";

        bucket.setName(updatedName);
        bucket.setDescription(updatedDesc);
        bucket.setAllowExtensionBundleRedeploy(true);

        metadataService.updateBucket(bucket);

        final BucketEntity updatedBucket = metadataService.getBucketById(bucket.getId());
        assertNotNull(updatedName);
        assertEquals(updatedName, updatedBucket.getName());
        assertEquals(updatedDesc, updatedBucket.getDescription());
        assertTrue(updatedBucket.isAllowExtensionBundleRedeploy());
    }

    @Test
    public void testDeleteBucketNoChildren() {
        final BucketEntity bucket = metadataService.getBucketById("6");
        assertNotNull(bucket);

        metadataService.deleteBucket(bucket);

        final BucketEntity deletedBucket = metadataService.getBucketById("6");
        assertNull(deletedBucket);
    }

    @Test
    public void testDeleteBucketWithChildren() {
        final BucketEntity bucket = metadataService.getBucketById("1");
        assertNotNull(bucket);

        metadataService.deleteBucket(bucket);

        final BucketEntity deletedBucket = metadataService.getBucketById("1");
        assertNull(deletedBucket);
    }

    @Test
    public void testGetBucketsForIds() {
        final List<BucketEntity> buckets = metadataService.getBuckets(new HashSet<>(Arrays.asList("1", "2")));
        assertNotNull(buckets);
        assertEquals(2, buckets.size());
        assertEquals("1", buckets.get(0).getId());
        assertEquals("2", buckets.get(1).getId());
    }

    @Test
    public void testGetAllBuckets() {
        final List<BucketEntity> buckets = metadataService.getAllBuckets();
        assertNotNull(buckets);
        assertEquals(6, buckets.size());
    }

    //----------------- BucketItems ---------------------------------

    @Test
    public void testGetBucketItemsForBucket() {
        final BucketEntity bucket = metadataService.getBucketById("1");
        assertNotNull(bucket);

        final List<BucketItemEntity> items = metadataService.getBucketItems(bucket.getId());
        assertNotNull(items);
        assertEquals(2, items.size());

        items.stream().forEach(i -> assertNotNull(i.getBucketName()));
    }

    @Test
    public void testGetBucketItemsForBuckets() {
        final List<BucketItemEntity> items = metadataService.getBucketItems(new HashSet<>(Arrays.asList("1", "2")));
        assertNotNull(items);
        assertEquals(3, items.size());

        items.stream().forEach(i -> assertNotNull(i.getBucketName()));
    }

    @Test
    public void testGetItemsWithCounts() {
        final List<BucketItemEntity> items = metadataService.getBucketItems(new HashSet<>(Arrays.asList("1", "2")));
        assertNotNull(items);

        // 3 items across all buckets
        assertEquals(3, items.size());

        final BucketItemEntity item1 = items.stream().filter(i -> i.getId().equals("1")).findFirst().orElse(null);
        assertNotNull(item1);
        assertEquals(BucketItemEntityType.FLOW, item1.getType());

        final FlowEntity flowEntity = (FlowEntity) item1;
        assertEquals(3, flowEntity.getSnapshotCount());

        items.stream().forEach(i -> assertNotNull(i.getBucketName()));
    }

    @Test
    public void testGetItemsWithCountsFilteredByBuckets() {
        final List<BucketItemEntity> items = metadataService.getBucketItems(Collections.singleton("1"));
        assertNotNull(items);

        // only 2 items in bucket 1
        assertEquals(2, items.size());

        final BucketItemEntity item1 = items.stream().filter(i -> i.getId().equals("1")).findFirst().orElse(null);
        assertNotNull(item1);
        assertEquals(BucketItemEntityType.FLOW, item1.getType());

        final FlowEntity flowEntity = (FlowEntity) item1;
        assertEquals(3, flowEntity.getSnapshotCount());

        items.stream().forEach(i -> assertNotNull(i.getBucketName()));
    }

    //----------------- Flows ---------------------------------

    @Test
    public void testGetFlowByIdWhenExists() {
        final FlowEntity flow = metadataService.getFlowById("1");
        assertNotNull(flow);
        assertEquals("1", flow.getId());
        assertEquals("1", flow.getBucketId());
    }

    @Test
    public void testGetFlowByIdWhenDoesNotExist() {
        final FlowEntity flow = metadataService.getFlowById("does-not-exist");
        assertNull(flow);
    }

    @Test
    public void testCreateFlow() {
        final String bucketId = "1";

        final FlowEntity flow = new FlowEntity();
        flow.setId(UUID.randomUUID().toString());
        flow.setBucketId(bucketId);
        flow.setName("Test Flow 1");
        flow.setDescription("Description for Test Flow 1");
        flow.setCreated(new Date());
        flow.setModified(new Date());
        flow.setType(BucketItemEntityType.FLOW);

        metadataService.createFlow(flow);

        final FlowEntity createdFlow = metadataService.getFlowById(flow.getId());
        assertNotNull(flow);
        assertEquals(flow.getId(), createdFlow.getId());
        assertEquals(flow.getBucketId(), createdFlow.getBucketId());
        assertEquals(flow.getName(), createdFlow.getName());
        assertEquals(flow.getDescription(), createdFlow.getDescription());
        assertEquals(flow.getCreated(), createdFlow.getCreated());
        assertEquals(flow.getModified(), createdFlow.getModified());
        assertEquals(flow.getType(), createdFlow.getType());
    }

    @Test
    public void testGetFlowByIdWithSnapshotCount() {
       final FlowEntity flowEntity = metadataService.getFlowByIdWithSnapshotCounts("1");
        assertNotNull(flowEntity);
        assertEquals(3, flowEntity.getSnapshotCount());
    }

    @Test
    public void testGetFlowsByBucket() {
        final BucketEntity bucketEntity = metadataService.getBucketById("1");
        final List<FlowEntity> flows = metadataService.getFlowsByBucket(bucketEntity.getId());
        assertEquals(2, flows.size());

        final FlowEntity flowEntity = flows.stream().filter(f -> f.getId().equals("1")).findFirst().orElse(null);
        assertNotNull(flowEntity);
        assertEquals(3, flowEntity.getSnapshotCount());
    }

    @Test
    public void testGetFlowsByName() {
        final List<FlowEntity> flows = metadataService.getFlowsByName("Flow 1");
        assertNotNull(flows);
        assertEquals(2, flows.size());
        assertEquals("Flow 1", flows.get(0).getName());
        assertEquals("Flow 1", flows.get(1).getName());
    }

    @Test
    public void testGetFlowsByNameByBucket() {
        final List<FlowEntity> flows = metadataService.getFlowsByName("2","Flow 1");
        assertNotNull(flows);
        assertEquals(1, flows.size());
        assertEquals("Flow 1", flows.get(0).getName());
        assertEquals("2", flows.get(0).getBucketId());
    }

    @Test
    public void testUpdateFlow() {
        final FlowEntity flow = metadataService.getFlowById("1");
        assertNotNull(flow);

        final Date originalModified = flow.getModified();

        flow.setName(flow.getName() + " UPDATED");
        flow.setDescription(flow.getDescription() + " UPDATED");

        metadataService.updateFlow(flow);

        final FlowEntity updatedFlow = metadataService.getFlowById( "1");
        assertNotNull(flow);
        assertEquals(flow.getName(), updatedFlow.getName());
        assertEquals(flow.getDescription(), updatedFlow.getDescription());
        assertEquals(flow.getModified().getTime(), updatedFlow.getModified().getTime());
        assertTrue(updatedFlow.getModified().getTime() > originalModified.getTime());
    }

    @Test
    public void testDeleteFlowWithSnapshots() {
        final FlowEntity flow = metadataService.getFlowById( "1");
        assertNotNull(flow);

        metadataService.deleteFlow(flow);

        final FlowEntity deletedFlow = metadataService.getFlowById("1");
        assertNull(deletedFlow);
    }

    //----------------- FlowSnapshots ---------------------------------

    @Test
    public void testGetFlowSnapshot() {
        final FlowSnapshotEntity entity = metadataService.getFlowSnapshot( "1", 1);
        assertNotNull(entity);
        assertEquals("1", entity.getFlowId());
        assertEquals(1, entity.getVersion().intValue());
    }

    @Test
    public void testGetFlowSnapshotDoesNotExist() {
        final FlowSnapshotEntity entity = metadataService.getFlowSnapshot( "DOES-NOT-EXIST", 1);
        assertNull(entity);
    }

    @Test
    public void testCreateFlowSnapshot() {
        final FlowSnapshotEntity flowSnapshot = new FlowSnapshotEntity();
        flowSnapshot.setFlowId("1");
        flowSnapshot.setVersion(4);
        flowSnapshot.setCreated(new Date());
        flowSnapshot.setCreatedBy("test-user");
        flowSnapshot.setComments("Comments");

        metadataService.createFlowSnapshot(flowSnapshot);

        final FlowSnapshotEntity createdFlowSnapshot = metadataService.getFlowSnapshot(flowSnapshot.getFlowId(), flowSnapshot.getVersion());
        assertNotNull(createdFlowSnapshot);
        assertEquals(flowSnapshot.getFlowId(), createdFlowSnapshot.getFlowId());
        assertEquals(flowSnapshot.getVersion(), createdFlowSnapshot.getVersion());
        assertEquals(flowSnapshot.getComments(), createdFlowSnapshot.getComments());
        assertEquals(flowSnapshot.getCreated(), createdFlowSnapshot.getCreated());
        assertEquals(flowSnapshot.getCreatedBy(), createdFlowSnapshot.getCreatedBy());
    }

    @Test
    public void testGetLatestSnapshot() {
        final FlowSnapshotEntity latest = metadataService.getLatestSnapshot("1");
        assertNotNull(latest);
        assertEquals("1", latest.getFlowId());
        assertEquals(3, latest.getVersion().intValue());
    }

    @Test
    public void testGetLatestSnapshotDoesNotExist() {
        final FlowSnapshotEntity latest = metadataService.getLatestSnapshot("DOES-NOT-EXIST");
        assertNull(latest);
    }

    @Test
    public void testGetFlowSnapshots() {
        final List<FlowSnapshotEntity> flowSnapshots = metadataService.getSnapshots( "1");
        assertNotNull(flowSnapshots);
        assertEquals(3, flowSnapshots.size());
    }

    @Test
    public void testGetFlowSnapshotsNoneFound() {
        final List<FlowSnapshotEntity> flowSnapshots = metadataService.getSnapshots( "2");
        assertNotNull(flowSnapshots);
        assertEquals(0, flowSnapshots.size());
    }

    @Test
    public void testDeleteFlowSnapshot() {
        final FlowSnapshotEntity entity = metadataService.getFlowSnapshot( "1", 1);
        assertNotNull(entity);

        metadataService.deleteFlowSnapshot(entity);

        final FlowSnapshotEntity deletedEntity = metadataService.getFlowSnapshot( "1", 1);
        assertNull(deletedEntity);
    }

    //----------------- Extension Bundles ---------------------------------

    @Test
    public void testGetExtensionBundleById() {
        final ExtensionBundleEntity entity = metadataService.getExtensionBundle("eb1");
        assertNotNull(entity);

        assertEquals("eb1", entity.getId());
        assertEquals("nifi-example-processors-nar", entity.getName());
        assertEquals("Example processors bundle", entity.getDescription());
        assertNotNull(entity.getCreated());
        assertNotNull(entity.getModified());
        assertEquals(BucketItemEntityType.EXTENSION_BUNDLE, entity.getType());
        assertEquals("3", entity.getBucketId());

        assertEquals(ExtensionBundleEntityType.NIFI_NAR, entity.getBundleType());

        assertEquals("org.apache.nifi", entity.getGroupId());
        assertEquals("nifi-example-processors-nar", entity.getArtifactId());
    }

    @Test
    public void testGetExtensionBundleDoesNotExist() {
        final ExtensionBundleEntity entity = metadataService.getExtensionBundle("does-not-exist");
        assertNull(entity);
    }

    @Test
    public void testGetExtensionBundleByGroupArtifact() {
        final String bucketId = "3";
        final String group = "org.apache.nifi";
        final String artifact = "nifi-example-service-api-nar";

        final ExtensionBundleEntity entity = metadataService.getExtensionBundle(bucketId, group, artifact);
        assertNotNull(entity);
        assertEquals(bucketId, entity.getBucketId());

        assertEquals(group, entity.getGroupId());
        assertEquals(artifact, entity.getArtifactId());
    }

    @Test
    public void testGetExtensionBundleByGroupArtifactDoesNotExist() {
        final String bucketId = "3";
        final String group = "org.apache.nifi";
        final String artifact = "does-not-exist";

        final ExtensionBundleEntity entity = metadataService.getExtensionBundle(bucketId, group, artifact);
        assertNull(entity);
    }

    @Test
    public void testGetExtensionBundlesWithEmptyFilterParams() {
        final Set<String> bucketIds = new HashSet<>();
        bucketIds.add("1");
        bucketIds.add("2");
        bucketIds.add("3");

        final List<ExtensionBundleEntity> bundles = metadataService.getExtensionBundles(bucketIds, ExtensionBundleFilterParams.empty());
        assertNotNull(bundles);
        assertEquals(3, bundles.size());

        bundles.forEach(b -> {
            assertTrue(b.getVersionCount() > 0);
            assertNotNull(b.getBucketName());
        });
    }

    @Test
    public void testGetExtensionBundlesWithFilterParams() {
        final Set<String> bucketIds = new HashSet<>();
        bucketIds.add("1");
        bucketIds.add("2");
        bucketIds.add("3");

        final List<ExtensionBundleEntity> bundles = metadataService.getExtensionBundles(bucketIds,
                ExtensionBundleFilterParams.empty());
        assertNotNull(bundles);
        assertEquals(3, bundles.size());

        final List<ExtensionBundleEntity> bundles2 = metadataService.getExtensionBundles(bucketIds,
                ExtensionBundleFilterParams.of("org.apache.nifi", null));
        assertNotNull(bundles2);
        assertEquals(2, bundles2.size());

        final List<ExtensionBundleEntity> bundles3 = metadataService.getExtensionBundles(bucketIds,
                ExtensionBundleFilterParams.of("org.apache.%", null));
        assertNotNull(bundles3);
        assertEquals(2, bundles3.size());

        final List<ExtensionBundleEntity> bundles4 = metadataService.getExtensionBundles(bucketIds,
                ExtensionBundleFilterParams.of("org.apache.nifi", "nifi-example-processors-nar"));
        assertNotNull(bundles4);
        assertEquals(1, bundles4.size());

        final List<ExtensionBundleEntity> bundles5 = metadataService.getExtensionBundles(bucketIds,
                ExtensionBundleFilterParams.of("org.apache.nifi", "nifi-example-processors-%"));
        assertNotNull(bundles5);
        assertEquals(1, bundles5.size());

        final List<ExtensionBundleEntity> bundles6 = metadataService.getExtensionBundles(bucketIds,
                ExtensionBundleFilterParams.of(null, "nifi-example-processors-%"));
        assertNotNull(bundles6);
        assertEquals(1, bundles6.size());
    }

    @Test
    public void testGetExtensionBundlesByBucket() {
        final List<ExtensionBundleEntity> bundles = metadataService.getExtensionBundlesByBucket("3");
        assertNotNull(bundles);
        assertEquals(3, bundles.size());

        final List<ExtensionBundleEntity> bundles2 = metadataService.getExtensionBundlesByBucket("6");
        assertNotNull(bundles2);
        assertEquals(0, bundles2.size());
    }

    @Test
    public void testGetExtensionBundlesByBucketAndGroup() {
        final List<ExtensionBundleEntity> bundles = metadataService.getExtensionBundlesByBucketAndGroup("3", "org.apache.nifi");
        assertNotNull(bundles);
        assertEquals(2, bundles.size());

        final List<ExtensionBundleEntity> bundles2 = metadataService.getExtensionBundlesByBucketAndGroup("3", "does-not-exist");
        assertNotNull(bundles2);
        assertEquals(0, bundles2.size());
    }

    @Test
    public void testCreateExtensionBundle() {
        final ExtensionBundleEntity entity = new ExtensionBundleEntity();
        entity.setId(UUID.randomUUID().toString());
        entity.setBucketId("3");
        entity.setName("nifi-foo-nar");
        entity.setDescription("This is foo nar");
        entity.setCreated(new Date());
        entity.setModified(new Date());
        entity.setGroupId("org.apache.nifi");
        entity.setArtifactId("nifi-foo-nar");
        entity.setBundleType(ExtensionBundleEntityType.NIFI_NAR);

        final ExtensionBundleEntity createdEntity = metadataService.createExtensionBundle(entity);
        assertNotNull(createdEntity);

        final List<ExtensionBundleEntity> bundles = metadataService.getExtensionBundlesByBucket("3");
        assertNotNull(bundles);
        assertEquals(4, bundles.size());
    }

    @Test
    public void testDeleteExtensionBundle() {
        final List<ExtensionBundleEntity> bundles = metadataService.getExtensionBundlesByBucket("3");
        assertNotNull(bundles);
        assertEquals(3, bundles.size());

        final ExtensionBundleEntity existingBundle = bundles.get(0);
        metadataService.deleteExtensionBundle(existingBundle);

        final ExtensionBundleEntity deletedBundle = metadataService.getExtensionBundle(existingBundle.getId());
        assertNull(deletedBundle);

        final List<ExtensionBundleEntity> bundlesAfterDelete = metadataService.getExtensionBundlesByBucket("3");
        assertNotNull(bundlesAfterDelete);
        assertEquals(2, bundlesAfterDelete.size());
    }

    @Test
    public void testDeleteBucketWithExtensionBundles() {
        final List<ExtensionBundleEntity> bundles = metadataService.getExtensionBundlesByBucket("3");
        assertNotNull(bundles);
        assertEquals(3, bundles.size());

        final BucketEntity bucket = metadataService.getBucketById("3");
        assertNotNull(bucket);
        metadataService.deleteBucket(bucket);

        final List<ExtensionBundleEntity> bundlesAfterDelete = metadataService.getExtensionBundlesByBucket("3");
        assertNotNull(bundlesAfterDelete);
        assertEquals(0, bundlesAfterDelete.size());
    }

    //----------------- Extension Bundle Versions ---------------------------------

    @Test
    public void testCreateExtensionBundleVersion() {
        final ExtensionBundleVersionEntity bundleVersion = new ExtensionBundleVersionEntity();
        bundleVersion.setId(UUID.randomUUID().toString());
        bundleVersion.setExtensionBundleId("eb1");
        bundleVersion.setVersion("1.1.0");
        bundleVersion.setCreated(new Date());
        bundleVersion.setCreatedBy("user2");
        bundleVersion.setDescription("This is v1.1.0");
        bundleVersion.setSha256Hex("123456789");
        bundleVersion.setSha256Supplied(false);
        bundleVersion.setContentSize(2048);

        metadataService.createExtensionBundleVersion(bundleVersion);

        final ExtensionBundleVersionEntity createdBundleVersion = metadataService.getExtensionBundleVersion("eb1", "1.1.0");
        assertNotNull(createdBundleVersion);
        assertEquals(bundleVersion.getId(), createdBundleVersion.getId());
        assertFalse(bundleVersion.getSha256Supplied());
    }

    @Test
    public void testGetExtensionBundleVersionsWithEmptyBucketIdsAndEmptyFilterParams() {
        final List<ExtensionBundleVersionEntity> versionEntities = metadataService.getExtensionBundleVersions(
                Collections.emptySet(), ExtensionBundleVersionFilterParams.empty());
        assertEquals(0, versionEntities.size());
    }

    @Test
    public void testGetExtensionBundleVersionsWithEmptyFilterParams() {
        final Set<String> bucketIds = new HashSet<>();
        bucketIds.add("1");
        bucketIds.add("2");
        bucketIds.add("3");

        final List<ExtensionBundleVersionEntity> versionEntities = metadataService.getExtensionBundleVersions(
                bucketIds, ExtensionBundleVersionFilterParams.empty());
        assertEquals(3, versionEntities.size());
    }

    @Test
    public void testGetExtensionBundleVersionsWithFilterParams() {
        final Set<String> bucketIds = new HashSet<>();
        bucketIds.add("1");
        bucketIds.add("2");
        bucketIds.add("3");

        final List<ExtensionBundleVersionEntity> versionEntities = metadataService.getExtensionBundleVersions(
                bucketIds, ExtensionBundleVersionFilterParams.of("org.apache.nifi", null, null));
        assertEquals(2, versionEntities.size());

        final List<ExtensionBundleVersionEntity> versionEntities2 = metadataService.getExtensionBundleVersions(
                bucketIds, ExtensionBundleVersionFilterParams.of("org.apache.%", null, null));
        assertEquals(2, versionEntities2.size());

        final List<ExtensionBundleVersionEntity> versionEntities3 = metadataService.getExtensionBundleVersions(
                bucketIds, ExtensionBundleVersionFilterParams.of("org.apache.nifi", "nifi-example-processors-nar", null));
        assertEquals(1, versionEntities3.size());

        final List<ExtensionBundleVersionEntity> versionEntities4 = metadataService.getExtensionBundleVersions(
                bucketIds, ExtensionBundleVersionFilterParams.of("org.apache.nifi", "nifi-example-processors-%", null));
        assertEquals(1, versionEntities4.size());

        final List<ExtensionBundleVersionEntity> versionEntities5 = metadataService.getExtensionBundleVersions(
                bucketIds, ExtensionBundleVersionFilterParams.of("org.apache.nifi", "nifi-example-processors-nar", "1.0.0"));
        assertEquals(1, versionEntities5.size());

        final List<ExtensionBundleVersionEntity> versionEntities6 = metadataService.getExtensionBundleVersions(
                bucketIds, ExtensionBundleVersionFilterParams.of("org.apache.nifi", "nifi-example-processors-nar", "1.0.%"));
        assertEquals(1, versionEntities6.size());

        final List<ExtensionBundleVersionEntity> versionEntities7 = metadataService.getExtensionBundleVersions(
                bucketIds, ExtensionBundleVersionFilterParams.of("org.apache.nifi", "nifi-example-processors-nar", "NOT-FOUND"));
        assertEquals(0, versionEntities7.size());
    }

    @Test
    public void testGetExtensionBundleVersionByBundleIdAndVersion() {
        final ExtensionBundleVersionEntity bundleVersion = metadataService.getExtensionBundleVersion("eb1", "1.0.0");
        assertNotNull(bundleVersion);
        assertEquals("eb1-v1", bundleVersion.getId());
        assertEquals("eb1", bundleVersion.getExtensionBundleId());
        assertEquals("1.0.0", bundleVersion.getVersion());
        assertNotNull(bundleVersion.getCreated());
        assertEquals("user1", bundleVersion.getCreatedBy());
        assertEquals("First version of eb1", bundleVersion.getDescription());
        assertTrue(bundleVersion.getSha256Supplied());
        assertEquals(1024, bundleVersion.getContentSize());
    }

    @Test
    public void testGetExtensionBundleVersionByBundleIdAndVersionDoesNotExist() {
        final ExtensionBundleVersionEntity bundleVersion = metadataService.getExtensionBundleVersion("does-not-exist", "1.0.0");
        assertNull(bundleVersion);
    }

    @Test
    public void testGetExtensionBundleVersionByBucketGroupArtifactVersion() {
        final String bucketId = "3";
        final String groupId = "org.apache.nifi";
        final String artifactId = "nifi-example-processors-nar";
        final String version = "1.0.0";

        final ExtensionBundleVersionEntity bundleVersion = metadataService.getExtensionBundleVersion(bucketId, groupId, artifactId, version);
        assertNotNull(bundleVersion);
        assertEquals("eb1-v1", bundleVersion.getId());
        assertTrue(bundleVersion.getSha256Supplied());
    }

    @Test
    public void testGetExtensionBundleVersionByBucketGroupArtifactVersionWhenDoesNotExist() {
        final String bucketId = "3";
        final String groupId = "org.apache.nifi";
        final String artifactId = "nifi-example-processors-nar";
        final String version = "FOO";

        final ExtensionBundleVersionEntity bundleVersion = metadataService.getExtensionBundleVersion(bucketId, groupId, artifactId, version);
        assertNull(bundleVersion);
    }

    @Test
    public void testGetExtensionBundleVersionsByBundleId() {
        final List<ExtensionBundleVersionEntity> bundleVersions = metadataService.getExtensionBundleVersions("eb1");
        assertNotNull(bundleVersions);
        assertEquals(1, bundleVersions.size());

        final ExtensionBundleVersionEntity bundleVersion = bundleVersions.get(0);
        assertEquals("eb1", bundleVersion.getExtensionBundleId());
    }

    @Test
    public void testGetExtensionBundleVersionsByBundleIdWhenDoesNotExist() {
        final List<ExtensionBundleVersionEntity> bundleVersions = metadataService.getExtensionBundleVersions("does-not-exist");
        assertNotNull(bundleVersions);
        assertEquals(0, bundleVersions.size());
    }

    @Test
    public void testGetExtensionBundleVersionsByBucketGroupArtifact() {
        final String bucketId = "3";
        final String groupId = "org.apache.nifi";
        final String artifactId = "nifi-example-processors-nar";

        final List<ExtensionBundleVersionEntity> bundleVersions = metadataService.getExtensionBundleVersions(bucketId, groupId, artifactId);
        assertNotNull(bundleVersions);
        assertEquals(1, bundleVersions.size());

        final ExtensionBundleVersionEntity bundleVersion = bundleVersions.get(0);
        assertEquals("eb1-v1", bundleVersion.getId());
    }

    @Test
    public void testGetExtensionBundleVersionsByBucketGroupArtifactWhenDoesNotExist() {
        final String bucketId = "3";
        final String groupId = "org.apache.nifi";
        final String artifactId = "does-not-exist";

        final List<ExtensionBundleVersionEntity> bundleVersions = metadataService.getExtensionBundleVersions(bucketId, groupId, artifactId);
        assertNotNull(bundleVersions);
        assertEquals(0, bundleVersions.size());
    }

    @Test
    public void testGetExtensionBundleVersionsGlobal() {
        final String groupId = "org.apache.nifi";
        final String artifactId = "nifi-example-processors-nar";
        final String version = "1.0.0";

        final List<ExtensionBundleVersionEntity> bundleVersions = metadataService.getExtensionBundleVersionsGlobal(groupId, artifactId, version);
        assertNotNull(bundleVersions);
        assertEquals(1, bundleVersions.size());

        final ExtensionBundleVersionEntity bundleVersion = bundleVersions.get(0);
        assertEquals("eb1-v1", bundleVersion.getId());
    }

    @Test
    public void testDeleteExtensionBundleVersion() {
        final ExtensionBundleVersionEntity bundleVersion = metadataService.getExtensionBundleVersion("eb1", "1.0.0");
        assertNotNull(bundleVersion);

        metadataService.deleteExtensionBundleVersion(bundleVersion);

        final ExtensionBundleVersionEntity deletedBundleVersion = metadataService.getExtensionBundleVersion("eb1", "1.0.0");
        assertNull(deletedBundleVersion);
    }

    // ---------- Extension Bundle Version Dependencies ------------

    @Test
    public void testCreateExtensionBundleVersionDependency() {
        final ExtensionBundleVersionEntity versionEntity = metadataService.getExtensionBundleVersion("eb1", "1.0.0");
        assertNotNull(versionEntity);

        final List<ExtensionBundleVersionDependencyEntity> dependencies = metadataService.getDependenciesForBundleVersion(versionEntity.getId());
        assertNotNull(dependencies);
        assertEquals(1, dependencies.size());

        final ExtensionBundleVersionDependencyEntity dependencyEntity = new ExtensionBundleVersionDependencyEntity();
        dependencyEntity.setId(UUID.randomUUID().toString());
        dependencyEntity.setExtensionBundleVersionId(versionEntity.getId());
        dependencyEntity.setGroupId("com.foo");
        dependencyEntity.setArtifactId("foo-nar");
        dependencyEntity.setVersion("1.1.1");

        metadataService.createDependency(dependencyEntity);

        final List<ExtensionBundleVersionDependencyEntity> dependencies2 = metadataService.getDependenciesForBundleVersion(versionEntity.getId());
        assertNotNull(dependencies2);
        assertEquals(2, dependencies2.size());
    }

    @Test
    public void testGetExtensionBundleVersionDependencies() {
        final List<ExtensionBundleVersionDependencyEntity> dependencies = metadataService.getDependenciesForBundleVersion("eb1-v1");
        assertNotNull(dependencies);
        assertEquals(1, dependencies.size());

        final ExtensionBundleVersionDependencyEntity dependency = dependencies.get(0);
        assertEquals("eb1-v1-dep1", dependency.getId());
        assertEquals("eb1-v1", dependency.getExtensionBundleVersionId());
        assertEquals("org.apache.nifi", dependency.getGroupId());
        assertEquals("nifi-example-service-api-nar", dependency.getArtifactId());
        assertEquals("2.0.0", dependency.getVersion());
    }

    @Test
    public void testGetExtensionBundleVersionDependenciesWhenNoneExist() {
        final List<ExtensionBundleVersionDependencyEntity> dependencies = metadataService.getDependenciesForBundleVersion("DOES-NOT-EXIST");
        assertNotNull(dependencies);
        assertEquals(0, dependencies.size());
    }

    //----------------- Extensions ---------------------------------

    @Test
    public void testCreateExtension() {
        final ExtensionEntity extension = new ExtensionEntity();
        extension.setId("4");
        extension.setExtensionBundleVersionId("eb1-v1");
        extension.setType("com.example.FooBarProcessor");
        extension.setTypeDescription("This the FoorBarProcessor");
        extension.setCategory(ExtensionEntityCategory.PROCESSOR);
        extension.setRestricted(false);
        extension.setTags("tag1, tag2");

        metadataService.createExtension(extension);

        final ExtensionEntity retrievedExtension = metadataService.getExtensionById(extension.getId());
        assertEquals(extension.getId(), retrievedExtension.getId());
        assertEquals(extension.getExtensionBundleVersionId(), retrievedExtension.getExtensionBundleVersionId());
        assertEquals(extension.getType(), retrievedExtension.getType());
        assertEquals(extension.getTypeDescription(), retrievedExtension.getTypeDescription());
        assertEquals(extension.getCategory(), retrievedExtension.getCategory());
        assertEquals(extension.isRestricted(), retrievedExtension.isRestricted());
        assertEquals(extension.getTags(), retrievedExtension.getTags());

        final List<ExtensionEntity> tag1Extensions = metadataService.getExtensionsByTag("tag1");
        assertNotNull(tag1Extensions);
        assertEquals(1, tag1Extensions.size());
        assertEquals(extension.getId(), tag1Extensions.get(0).getId());

        final List<ExtensionEntity> tag2Extensions = metadataService.getExtensionsByTag("tag2");
        assertNotNull(tag2Extensions);
        assertEquals(1, tag2Extensions.size());
        assertEquals(extension.getId(), tag2Extensions.get(0).getId());
    }

    @Test
    public void testGetExtensionById() {
        final ExtensionEntity extension = metadataService.getExtensionById("e1");
        assertNotNull(extension);
        assertEquals("e1", extension.getId());
        assertEquals("org.apache.nifi.ExampleProcessor", extension.getType());
    }

    @Test
    public void testGetExtensionByIdDoesNotExist() {
        final ExtensionEntity extension = metadataService.getExtensionById("does-not-exist");
        assertNull(extension);
    }

    @Test
    public void testGetAllExtensions() {
        final List<ExtensionEntity> extensions = metadataService.getAllExtensions();
        assertNotNull(extensions);
        assertEquals(3, extensions.size());
    }

    @Test
    public void testGetExtensionsByBundleVersionId() {
        final List<ExtensionEntity> extensions = metadataService.getExtensionsByBundleVersionId("eb1-v1");
        assertNotNull(extensions);
        assertEquals(2, extensions.size());
    }

    @Test
    public void testGetExtensionsByBundleVersionIdDoesNotExist() {
        final List<ExtensionEntity> extensions = metadataService.getExtensionsByBundleVersionId("does-not-exist");
        assertNotNull(extensions);
        assertEquals(0, extensions.size());
    }

    @Test
    public void testGetExtensionsByBundleCoordinate() {
        final String bucketId = "3";
        final String groupId = "org.apache.nifi";
        final String artifactId = "nifi-example-processors-nar";
        final String version = "1.0.0";

        final List<ExtensionEntity> extensions = metadataService.getExtensionsByBundleCoordinate(bucketId, groupId, artifactId, version);
        assertNotNull(extensions);
        assertEquals(2, extensions.size());
    }

    @Test
    public void testGetExtensionsByBundleCoordinateDoesNotExist() {
        final String bucketId = "3";
        final String groupId = "org.apache.nifi";
        final String artifactId = "does-not-exist";
        final String version = "1.0.0";

        final List<ExtensionEntity> extensions = metadataService.getExtensionsByBundleCoordinate(bucketId, groupId, artifactId, version);
        assertNotNull(extensions);
        assertEquals(0, extensions.size());
    }

    @Test
    public void testGetExtensionsByCategory() {
        final List<ExtensionEntity> services = metadataService.getExtensionsByCategory(ExtensionEntityCategory.CONTROLLER_SERVICE);
        assertNotNull(services);
        assertEquals(1, services.size());

        final List<ExtensionEntity> processors = metadataService.getExtensionsByCategory(ExtensionEntityCategory.PROCESSOR);
        assertNotNull(processors);
        assertEquals(2, processors.size());
    }

    @Test
    public void testGetExtensionTags() {
        final Set<String> tags = metadataService.getAllExtensionTags();
        assertNotNull(tags);
        assertEquals(4, tags.size());
    }

    @Test
    public void testDeleteExtension() {
        final ExtensionEntity extension = metadataService.getExtensionById("e1");
        assertNotNull(extension);

        metadataService.deleteExtension(extension);

        final ExtensionEntity deletedExtension = metadataService.getExtensionById("e1");
        assertNull(deletedExtension);
    }

}