ContentManagerTest.java

/**
 * Copyright (c) 2009 - 2012 Red Hat, Inc.
 *
 * This software is licensed to you under the GNU General Public License,
 * version 2 (GPLv2). There is NO WARRANTY for this software, express or
 * implied, including the implied warranties of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2
 * along with this software; if not, see
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 *
 * Red Hat trademarks are not licensed under GPLv2. No permission is
 * granted to use or replicate Red Hat trademarks that are incorporated
 * in this software or its documentation.
 */
package org.candlepin.controller;

import static org.junit.Assert.*;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.*;
import static org.mockito.AdditionalAnswers.*;

import junitparams.JUnitParamsRunner;
import junitparams.Parameters;

import org.candlepin.model.Content;
import org.candlepin.model.Owner;
import org.candlepin.model.Product;
import org.candlepin.model.dto.ContentData;
import org.candlepin.test.DatabaseTestFixture;
import org.candlepin.test.TestUtil;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.Arrays;



/**
 * ContentManagerTest
 */
@RunWith(JUnitParamsRunner.class)
public class ContentManagerTest extends DatabaseTestFixture {

    private ContentManager contentManager;
    private EntitlementCertificateGenerator mockEntCertGenerator;
    private ProductManager productManager;

    @Before
    public void setup() throws Exception {
        this.mockEntCertGenerator = mock(EntitlementCertificateGenerator.class);

        this.productManager = new ProductManager(
            this.mockEntCertGenerator, this.ownerContentCurator, this.ownerProductCurator,
            this.productCurator
        );

        this.contentManager = new ContentManager(
            this.contentCurator, this.mockEntCertGenerator, this.ownerContentCurator,
            this.productCurator, this.productManager
        );
    }

    @Test
    public void testCreateContent() {
        Owner owner = this.createOwner("test-owner", "Test Owner");
        ContentData dto = TestUtil.createContentDTO("c1", "content-1");
        dto.setLabel("test-label");
        dto.setType("test-test");
        dto.setVendor("test-vendor");

        assertNull(this.ownerContentCurator.getContentById(owner, dto.getId()));

        Content output = this.contentManager.createContent(dto, owner);

        assertEquals(output, this.ownerContentCurator.getContentById(owner, dto.getId()));
    }

    @Test(expected = IllegalStateException.class)
    public void testCreateContentThatAlreadyExists() {
        Owner owner = this.createOwner("test-owner", "Test Owner");

        ContentData dto = TestUtil.createContentDTO("c1", "content-1");
        dto.setLabel("test-label");
        dto.setType("test-test");
        dto.setVendor("test-vendor");

        Content output = this.contentManager.createContent(dto, owner);

        // Verify the creation worked
        assertNotNull(output);
        assertEquals(output, this.ownerContentCurator.getContentById(owner, dto.getId()));

        // This should fail, since it already exists
        this.contentManager.createContent(dto, owner);
    }

    @Test
    public void testCreateContentMergeWithExisting() {
        Owner owner1 = this.createOwner("test-owner-1", "Test Owner 1");
        Owner owner2 = this.createOwner("test-owner-2", "Test Owner 2");

        Content content1 = TestUtil.createContent("c1", "content-1");
        Content content2 = this.createContent("c1", "content-1", owner2);

        Content output = this.contentManager.createContent(content1.toDTO(), owner1);

        assertEquals(content2.getUuid(), output.getUuid());
        assertEquals(content2, output);
        assertTrue(this.ownerContentCurator.isContentMappedToOwner(output, owner1));
        assertTrue(this.ownerContentCurator.isContentMappedToOwner(output, owner2));
    }

    @Test
    public void testUpdateContentNoChange() {
        Owner owner = this.createOwner("test-owner", "Test Owner");
        Product product = this.createProduct("p1", "product-1", owner);
        Content content = this.createContent("c1", "content-1", owner);
        product.addContent(content, true);
        product = this.productCurator.merge(product);

        Content output = this.contentManager.updateContent(content.toDTO(), owner, true);

        assertEquals(output.getUuid(), content.getUuid());
        assertEquals(output, content);

        verifyZeroInteractions(this.mockEntCertGenerator);
    }

    @Test
    @Parameters({"false", "true"})
    public void testUpdateContent(boolean regenCerts) {
        Owner owner = this.createOwner("test-owner", "Test Owner");
        Product product = this.createProduct("p1", "product-1", owner);
        Content content = this.createContent("c1", "content-1", owner);
        ContentData update = TestUtil.createContentDTO("c1", "new content name");
        product.addContent(content, true);
        product = this.productCurator.merge(product);

        Content output = this.contentManager.updateContent(update, owner, regenCerts);

        assertNotEquals(output.getUuid(), content.getUuid());
        assertEquals(output.getName(), update.getName());

        // We expect the original to be kept around as an orphan until the orphan removal job
        // gets around to removing them
        assertNotNull(this.contentCurator.find(content.getUuid()));
        assertEquals(0, this.ownerContentCurator.getOwnerCount(content));
        assertNotNull(this.ownerContentCurator.getContentById(owner, content.getId()));

        // The product should have also changed in the same way as a result of the content change
        assertNotNull(this.productCurator.find(product.getUuid()));
        assertEquals(0, this.ownerProductCurator.getOwnerCount(product));
        assertNotNull(this.ownerProductCurator.getProductById(owner, product.getId()));

        if (regenCerts) {
            verify(this.mockEntCertGenerator, times(1)).regenerateCertificatesOf(
                eq(Arrays.asList(owner)), anyCollectionOf(Product.class), anyBoolean()
            );
        }
        else {
            verifyZeroInteractions(this.mockEntCertGenerator);
        }
    }

    @Test
    @Parameters({"false", "true"})
    public void testUpdateContentConvergeWithExisting(boolean regenCerts) {
        Owner owner1 = this.createOwner("test-owner-1", "Test Owner 1");
        Owner owner2 = this.createOwner("test-owner-2", "Test Owner 2");
        Product product = this.createProduct("p1", "product-1", owner1);
        Content content1 = this.createContent("c1", "content-1", owner1);
        Content content2 = this.createContent("c1", "updated content", owner2);
        ContentData update = TestUtil.createContentDTO("c1", "updated content");
        product.addContent(content1, true);
        product = this.productCurator.merge(product);

        assertTrue(this.ownerContentCurator.isContentMappedToOwner(content1, owner1));
        assertFalse(this.ownerContentCurator.isContentMappedToOwner(content2, owner1));
        assertFalse(this.ownerContentCurator.isContentMappedToOwner(content1, owner2));
        assertTrue(this.ownerContentCurator.isContentMappedToOwner(content2, owner2));

        Content output = this.contentManager.updateContent(update, owner1, regenCerts);

        assertEquals(content2.getUuid(), output.getUuid());
        assertFalse(this.ownerContentCurator.isContentMappedToOwner(content1, owner1));
        assertTrue(this.ownerContentCurator.isContentMappedToOwner(content2, owner1));
        assertFalse(this.ownerContentCurator.isContentMappedToOwner(content1, owner2));
        assertTrue(this.ownerContentCurator.isContentMappedToOwner(content2, owner2));

        if (regenCerts) {
            verify(this.mockEntCertGenerator, times(1)).regenerateCertificatesOf(
                eq(Arrays.asList(owner1)), anyCollectionOf(Product.class), anyBoolean()
            );
        }
        else {
            verifyZeroInteractions(this.mockEntCertGenerator);
        }
    }

    @Test
    @Parameters({"false", "true"})
    public void testUpdateContentDivergeFromExisting(boolean regenCerts) {
        Owner owner1 = this.createOwner("test-owner-1", "Test Owner 1");
        Owner owner2 = this.createOwner("test-owner-2", "Test Owner 2");
        Product product = this.createProduct("p1", "product-1", owner1);
        Content content = this.createContent("c1", "content-1", owner1, owner2);
        ContentData update = TestUtil.createContentDTO("c1", "updated content");
        product.addContent(content, true);
        product = this.productCurator.merge(product);

        assertTrue(this.ownerContentCurator.isContentMappedToOwner(content, owner1));
        assertTrue(this.ownerContentCurator.isContentMappedToOwner(content, owner2));

        Content output = this.contentManager.updateContent(update, owner1, regenCerts);

        assertNotEquals(output.getUuid(), content.getUuid());
        assertTrue(this.ownerContentCurator.isContentMappedToOwner(output, owner1));
        assertFalse(this.ownerContentCurator.isContentMappedToOwner(output, owner2));
        assertFalse(this.ownerContentCurator.isContentMappedToOwner(content, owner1));
        assertTrue(this.ownerContentCurator.isContentMappedToOwner(content, owner2));

        if (regenCerts) {
            verify(this.mockEntCertGenerator, times(1)).regenerateCertificatesOf(
                eq(Arrays.asList(owner1)), anyCollectionOf(Product.class), anyBoolean()
            );
        }
        else {
            verifyZeroInteractions(this.mockEntCertGenerator);
        }
    }

    @Test(expected = IllegalStateException.class)
    public void testUpdateContentThatDoesntExist() {
        Owner owner = this.createOwner("test-owner", "Test Owner");
        Content content = TestUtil.createContent("c1", "content-1");
        ContentData update = TestUtil.createContentDTO("c1", "new_name");

        assertFalse(this.ownerContentCurator.isContentMappedToOwner(content, owner));

        this.contentManager.updateContent(update, owner, false);
    }

    @Test
    @Parameters({"false", "true"})
    public void testRemoveContent(boolean regenCerts) {
        Owner owner = this.createOwner("test-owner-1", "Test Owner 1");
        Product product = this.createProduct("p1", "product-1", owner);
        Content content = this.createContent("c1", "content-1", owner);
        product.addContent(content, true);
        product = this.productCurator.merge(product);

        assertTrue(this.ownerContentCurator.isContentMappedToOwner(content, owner));

        try {
            this.beginTransaction();
            this.contentManager.removeContent(owner, content, regenCerts);
            this.commitTransaction();
        }
        catch (RuntimeException e) {
            this.rollbackTransaction();
        }

        assertFalse(this.ownerContentCurator.isContentMappedToOwner(content, owner));
        assertNotNull(this.contentCurator.find(content.getUuid()));
        assertEquals(0, this.ownerContentCurator.getOwnerCount(content));

        if (regenCerts) {
            verify(this.mockEntCertGenerator, times(1)).regenerateCertificatesOf(
                eq(Arrays.asList(owner)), anyCollectionOf(Product.class), anyBoolean()
            );
        }
        else {
            verifyZeroInteractions(this.mockEntCertGenerator);
        }
    }

    @Test
    @Parameters({"false", "true"})
    public void testRemoveContentDivergeFromExisting(boolean regenCerts) {
        Owner owner1 = this.createOwner("test-owner-1", "Test Owner 1");
        Owner owner2 = this.createOwner("test-owner-2", "Test Owner 2");
        Product product = this.createProduct("p1", "product-1", owner1, owner2);
        Content content = this.createContent("c1", "content-1", owner1, owner2);
        product.addContent(content, true);
        product = this.productCurator.merge(product);

        assertTrue(this.ownerContentCurator.isContentMappedToOwner(content, owner1));
        assertTrue(this.ownerContentCurator.isContentMappedToOwner(content, owner2));

        try {
            this.beginTransaction();
            this.contentManager.removeContent(owner1, content, regenCerts);
            this.commitTransaction();
        }
        catch (RuntimeException e) {
            this.rollbackTransaction();
        }

        assertFalse(this.ownerContentCurator.isContentMappedToOwner(content, owner1));
        assertTrue(this.ownerContentCurator.isContentMappedToOwner(content, owner2));
        assertNotNull(this.contentCurator.find(content.getUuid()));

        if (regenCerts) {
            verify(this.mockEntCertGenerator, times(1)).regenerateCertificatesOf(
                eq(Arrays.asList(owner1)), anyCollectionOf(Product.class), anyBoolean()
            );
        }
        else {
            verifyZeroInteractions(this.mockEntCertGenerator);
        }
    }

    @Test(expected = IllegalStateException.class)
    public void testRemoveContentThatDoesntExist() {
        Owner owner = this.createOwner("test-owner", "Test Owner");
        Content content = TestUtil.createContent("c1", "content-1");

        assertFalse(this.ownerContentCurator.isContentMappedToOwner(content, owner));

        this.contentManager.removeContent(owner, content, true);
    }


}