/**
* 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.model.dto;
import org.candlepin.common.jackson.DynamicPropertyFilter;
import org.candlepin.model.Content;
import org.candlepin.model.Product;
import org.candlepin.model.ProductContent;
import org.candlepin.util.Util;
import static org.junit.Assert.*;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import junitparams.JUnitParamsRunner;
import junitparams.Parameters;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* Test suite for the ProductData class
*/
@RunWith(JUnitParamsRunner.class)
public class ProductDataTest {
public static final String PRODUCT_JSON_BASE = "{" +
" \"created\" : \"2016-09-07T15:08:14+0000\"," +
" \"updated\" : \"2016-09-07T15:08:14+0000\"," +
" \"uuid\" : \"8a8d01cb570530d001570531389508c7\"," +
" \"id\" : \"dev-sku-product\"," +
" \"name\" : \"Development SKU Product\"," +
" \"multiplier\" : 1," +
" \"dependentProductIds\" : [ ]," +
" \"href\" : \"/products/8a8d01cb570530d001570531389508c7\"," +
" \"productContent\" : [ ]";
// public .* (?:get|is)(.*)\(\) {\npublic .* set\1\(.*\) {
// @Test
// public void testGetSet\1() {
// ProductData dto = new ProductData();
// String input = "test_value";
// String output = dto.get\1();
// assertNull(output);
// ProductData output2 = dto.set\1(input);
// assertSame(output2, dto);
// output = dto.get\1();
// assertEquals(input, output);
// }
private ObjectMapper mapper;
@Before
public void createObjects() {
this.mapper = new ObjectMapper();
SimpleFilterProvider filterProvider = new SimpleFilterProvider();
filterProvider.setDefaultFilter(new DynamicPropertyFilter());
this.mapper.setFilters(filterProvider);
}
protected Object[][] getBadStringValues() {
return new Object[][] {
new Object[] { null },
new Object[] { "" },
};
}
@Test
public void testGetSetUuid() {
ProductData dto = new ProductData();
String input = "test_value";
String output = dto.getUuid();
assertNull(output);
ProductData output2 = dto.setUuid(input);
assertSame(output2, dto);
output = dto.getUuid();
assertEquals(input, output);
}
@Test
public void testGetSetId() {
ProductData dto = new ProductData();
String input = "test_value";
String output = dto.getId();
assertNull(output);
ProductData output2 = dto.setId(input);
assertSame(output2, dto);
output = dto.getId();
assertEquals(input, output);
}
@Test(expected = IllegalArgumentException.class)
@Parameters(method = "getBadStringValues")
public void testGetSetIdBadValues(String input) {
ProductData dto = new ProductData();
String output = dto.getId();
assertNull(output);
dto.setId(input);
}
@Test
public void testGetSetName() {
ProductData dto = new ProductData();
String input = "test_value";
String output = dto.getName();
assertNull(output);
ProductData output2 = dto.setName(input);
assertSame(output2, dto);
output = dto.getName();
assertEquals(input, output);
}
@Test
public void testGetSetMultiplier() {
ProductData dto = new ProductData();
Long input = 1234L;
Long output = dto.getMultiplier();
assertNull(output);
ProductData output2 = dto.setMultiplier(input);
assertSame(output2, dto);
output = dto.getMultiplier();
assertEquals(input, output);
}
@Test
public void testGetSetAttributes() {
ProductData dto = new ProductData();
Map<String, String> input = new HashMap<String, String>();
input.put("a1", "v1");
input.put("a2", "v2");
input.put("a3", "v3");
Map<String, String> input2 = new HashMap<String, String>();
input2.put("a1", "old_value");
input2.put("a1", "v1");
input2.put("a2", "old_value");
input2.put("a2", "v2");
input2.put("a3", "old_value");
input2.put("a3", "v3");
Map<String, String> output = dto.getAttributes();
assertNull(output);
ProductData output2 = dto.setAttributes(input);
assertSame(dto, output2);
output = dto.getAttributes();
assertEquals(input, output);
// Second pass to ensure setAttributes is actually clearing existing attributes before
// adding new ones
output2 = dto.setAttributes(input);
assertSame(dto, output2);
output = dto.getAttributes();
assertEquals(input, output);
// Third pass to ensure setting duplicates doesn't allow the dupes to be retained
output2 = dto.setAttributes(input2);
assertSame(dto, output2);
output = dto.getAttributes();
assertEquals(input, output);
}
@Test
public void testgetAttributeValue() {
ProductData dto = new ProductData();
Map<String, String> input = new HashMap<String, String>();
input.put("a1", "v1");
input.put("a2", "v2");
input.put("a3", "v3");
String output = dto.getAttributeValue("a1");
assertNull(output);
dto.setAttributes(input);
output = dto.getAttributeValue("a1");
assertEquals("v1", output);
output = dto.getAttributeValue("a3");
assertEquals("v3", output);
output = dto.getAttributeValue("a4");
assertNull(output);
}
@Test
public void testHasAttribute() {
ProductData dto = new ProductData();
Map<String, String> input = new HashMap<String, String>();
input.put("a1", "v1");
input.put("a2", "v2");
input.put("a3", "v3");
boolean output = dto.hasAttribute("a1");
assertFalse(output);
dto.setAttributes(input);
output = dto.hasAttribute("a1");
assertTrue(output);
output = dto.hasAttribute("a3");
assertTrue(output);
output = dto.hasAttribute("a4");
assertFalse(output);
}
@Test
public void testSetAttributeByValue() {
ProductData dto = new ProductData();
Map<String, String> input1 = new HashMap<String, String>();
input1.put("a1", "v1");
Map<String, String> input2 = new HashMap<String, String>();
input2.put("a1", "v1");
input2.put("a2", "v2");
Map<String, String> input3 = new HashMap<String, String>();
input3.put("a1", "v1");
input3.put("a2", "v2");
input3.put("a3", "v3");
assertNull(dto.getAttributes());
ProductData output = dto.setAttribute("a1", "v1");
Map<String, String> output2 = dto.getAttributes();
assertSame(output, dto);
assertEquals(output2, input1);
output = dto.setAttribute("a1", "v1");
output2 = dto.getAttributes();
assertSame(output, dto);
assertEquals(output2, input1);
output = dto.setAttribute("a2", "v2");
output2 = dto.getAttributes();
assertSame(output, dto);
assertEquals(output2, input2);
output = dto.setAttribute("a3", "v3");
output2 = dto.getAttributes();
assertSame(output, dto);
assertEquals(output2, input3);
}
@Test
public void testRemoveAttribute() {
ProductData dto = new ProductData();
Map<String, String> input = new HashMap<String, String>();
input.put("a1", "v1");
input.put("a2", "v2");
Map<String, String> input2 = new HashMap<String, String>();
input2.put("a2", "v2");
assertNull(dto.getAttributes());
assertFalse(dto.removeAttribute("a1"));
assertFalse(dto.removeAttribute("a2"));
assertFalse(dto.removeAttribute("a3"));
dto.setAttributes(input);
assertEquals(input, dto.getAttributes());
boolean output = dto.removeAttribute("a1");
Map<String, String> output2 = dto.getAttributes();
assertTrue(output);
assertEquals(input2, output2);
output = dto.removeAttribute("a1");
output2 = dto.getAttributes();
assertFalse(output);
assertEquals(input2, output2);
// Note that the collection should not be nulled by removing the final element
output = dto.removeAttribute("a2");
output2 = dto.getAttributes();
assertTrue(output);
assertEquals(new HashMap<String, String>(), output2);
}
@Test
public void testGetSetProductContent() {
ProductData dto = new ProductData();
ContentData[] content = new ContentData[] {
new ContentData("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new ContentData("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
new ContentData("c3", "content-3", "test_type", "test_label-3", "test_vendor-3"),
};
Collection<ProductContentData> input = Arrays.asList(
new ProductContentData(content[0], true),
new ProductContentData(content[1], false),
new ProductContentData(content[2], true)
);
Collection<ProductContentData> input2 = Arrays.asList(
new ProductContentData(content[0], false),
new ProductContentData(content[0], true),
new ProductContentData(content[1], true),
new ProductContentData(content[1], false),
new ProductContentData(content[2], false),
new ProductContentData(content[2], true)
);
Collection<ProductContentData> output = dto.getProductContent();
assertNull(output);
ProductData output2 = dto.setProductContent(input);
assertSame(dto, output2);
output = dto.getProductContent();
assertTrue(Util.collectionsAreEqual(input, output));
// Second pass to ensure setProductContent is actually clearing existing content before
// adding new ones
output2 = dto.setProductContent(input);
assertSame(dto, output2);
output = dto.getProductContent();
assertTrue(Util.collectionsAreEqual(input, output));
// Third pass to ensure setting duplicates doesn't allow the dupes to be retained
output2 = dto.setProductContent(input2);
assertSame(dto, output2);
output = dto.getProductContent();
assertTrue(Util.collectionsAreEqual(input, output));
}
@Test
public void testGetProductContent() {
ProductData dto = new ProductData();
ContentData[] content = new ContentData[] {
new ContentData("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new ContentData("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
new ContentData("c3", "content-3", "test_type", "test_label-3", "test_vendor-3"),
};
ProductContentData pcdata1 = new ProductContentData(content[0], true);
ProductContentData pcdata2 = new ProductContentData(content[1], false);
ProductContentData pcdata3 = new ProductContentData(content[2], true);
ProductContentData output = dto.getProductContent("c1");
assertNull(output);
dto.setProductContent(Arrays.asList(pcdata1, pcdata2, pcdata3));
output = dto.getProductContent("c1");
assertEquals(pcdata1, output);
output = dto.getProductContent("c3");
assertEquals(pcdata3, output);
output = dto.getProductContent("c4");
assertNull(output);
}
@Test
public void testHasContent() {
ProductData dto = new ProductData();
ContentData[] content = new ContentData[] {
new ContentData("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new ContentData("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
new ContentData("c3", "content-3", "test_type", "test_label-3", "test_vendor-3"),
};
Collection<ProductContentData> input = Arrays.asList(
new ProductContentData(content[0], true),
new ProductContentData(content[1], false),
new ProductContentData(content[2], true)
);
boolean output = dto.hasContent("c1");
assertFalse(output);
dto.setProductContent(input);
output = dto.hasContent("c1");
assertTrue(output);
output = dto.hasContent("c3");
assertTrue(output);
output = dto.hasContent("c4");
assertFalse(output);
}
@Test
public void testAddProductContentByDTO() {
ProductData dto = new ProductData();
ContentData[] content = new ContentData[] {
new ContentData("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new ContentData("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
};
ProductContentData pcdata1 = new ProductContentData(content[0], true);
ProductContentData pcdata2 = new ProductContentData(content[1], false);
ProductContentData pcdata3 = new ProductContentData(content[1], true);
assertNull(dto.getProductContent());
boolean output = dto.addProductContent(pcdata1);
Collection<ProductContentData> output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1), output2));
output = dto.addProductContent(pcdata1);
output2 = dto.getProductContent();
assertFalse(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1), output2));
output = dto.addProductContent(pcdata2);
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1, pcdata2), output2));
output = dto.addProductContent(pcdata3);
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1, pcdata3), output2));
}
@Test
public void testAddProductContentByEntity() {
ProductData dto = new ProductData();
Content[] contentEntities = new Content[] {
new Content("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new Content("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
};
ProductContent pcentity1 = new ProductContent(null, contentEntities[0], true);
ProductContent pcentity2 = new ProductContent(null, contentEntities[1], false);
ProductContent pcentity3 = new ProductContent(null, contentEntities[1], true);
ContentData[] content = new ContentData[] {
contentEntities[0].toDTO(),
contentEntities[1].toDTO()
};
ProductContentData pcdata1 = new ProductContentData(content[0], true);
ProductContentData pcdata2 = new ProductContentData(content[1], false);
ProductContentData pcdata3 = new ProductContentData(content[1], true);
assertNull(dto.getProductContent());
boolean output = dto.addProductContent(pcentity1);
Collection<ProductContentData> output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1), output2));
output = dto.addProductContent(pcentity1);
output2 = dto.getProductContent();
assertFalse(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1), output2));
output = dto.addProductContent(pcentity2);
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1, pcdata2), output2));
output = dto.addProductContent(pcentity3);
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1, pcdata3), output2));
}
@Test
public void testAddContentByDTO() {
ProductData dto = new ProductData();
ContentData[] content = new ContentData[] {
new ContentData("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new ContentData("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
};
ProductContentData pcdata1 = new ProductContentData(content[0], true);
ProductContentData pcdata2 = new ProductContentData(content[1], false);
ProductContentData pcdata3 = new ProductContentData(content[1], true);
assertNull(dto.getProductContent());
boolean output = dto.addContent(pcdata1.getContent(), pcdata1.isEnabled());
Collection<ProductContentData> output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1), output2));
output = dto.addContent(pcdata1.getContent(), pcdata1.isEnabled());
output2 = dto.getProductContent();
assertFalse(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1), output2));
output = dto.addContent(pcdata2.getContent(), pcdata2.isEnabled());
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1, pcdata2), output2));
output = dto.addContent(pcdata3.getContent(), pcdata3.isEnabled());
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1, pcdata3), output2));
}
@Test
public void testAddContentByEntity() {
ProductData dto = new ProductData();
Content[] contentEntities = new Content[] {
new Content("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new Content("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
};
ProductContent pcentity1 = new ProductContent(null, contentEntities[0], true);
ProductContent pcentity2 = new ProductContent(null, contentEntities[1], false);
ProductContent pcentity3 = new ProductContent(null, contentEntities[1], true);
ContentData[] content = new ContentData[] {
contentEntities[0].toDTO(),
contentEntities[1].toDTO()
};
ProductContentData pcdata1 = new ProductContentData(content[0], true);
ProductContentData pcdata2 = new ProductContentData(content[1], false);
ProductContentData pcdata3 = new ProductContentData(content[1], true);
assertNull(dto.getProductContent());
boolean output = dto.addContent(pcentity1.getContent(), pcentity1.isEnabled());
Collection<ProductContentData> output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1), output2));
output = dto.addContent(pcentity1.getContent(), pcentity1.isEnabled());
output2 = dto.getProductContent();
assertFalse(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1), output2));
output = dto.addContent(pcentity2.getContent(), pcentity2.isEnabled());
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1, pcdata2), output2));
output = dto.addContent(pcentity3.getContent(), pcentity3.isEnabled());
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata1, pcdata3), output2));
}
@Test
public void testRemoveContentById() {
ProductData dto = new ProductData();
ContentData[] content = new ContentData[] {
new ContentData("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new ContentData("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
};
ProductContentData pcdata1 = new ProductContentData(content[0], true);
ProductContentData pcdata2 = new ProductContentData(content[1], false);
assertNull(dto.getProductContent());
assertFalse(dto.removeContent(content[0].getId()));
assertFalse(dto.removeContent(content[1].getId()));
dto.setProductContent(Arrays.asList(pcdata1, pcdata2));
boolean output = dto.removeContent(content[0].getId());
Collection<ProductContentData> output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata2), output2));
output = dto.removeContent(content[0].getId());
output2 = dto.getProductContent();
assertFalse(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata2), output2));
// Note that the collection should not be nulled by removing the final element
output = dto.removeContent(content[1].getId());
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Collections.<ProductContentData>emptyList(), output2));
}
@Test
public void testRemoveContentByDTO() {
ProductData dto = new ProductData();
ContentData[] content = new ContentData[] {
new ContentData("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new ContentData("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
new ContentData("c2", "content-3", "test_type", "test_label-3", "test_vendor-3"),
};
ProductContentData pcdata1 = new ProductContentData(content[0], true);
ProductContentData pcdata2 = new ProductContentData(content[1], false);
assertNull(dto.getProductContent());
assertFalse(dto.removeContent(content[0]));
assertFalse(dto.removeContent(content[1]));
assertFalse(dto.removeContent(content[2]));
dto.setProductContent(Arrays.asList(pcdata1, pcdata2));
boolean output = dto.removeContent(content[0]);
Collection<ProductContentData> output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata2), output2));
output = dto.removeContent(content[0]);
output2 = dto.getProductContent();
assertFalse(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata2), output2));
// This should work because we remove by content ID, not by exact element match
// Note that the collection should not be nulled by removing the final element
output = dto.removeContent(content[2]);
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Collections.<ProductContentData>emptyList(), output2));
}
@Test
public void testRemoveContentByEntity() {
ProductData dto = new ProductData();
ContentData[] content = new ContentData[] {
new ContentData("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new ContentData("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
};
ProductContentData pcdata1 = new ProductContentData(content[0], true);
ProductContentData pcdata2 = new ProductContentData(content[1], false);
Content[] contentEntities = new Content[] {
new Content("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new Content("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
new Content("c2", "content-3", "test_type", "test_label-3", "test_vendor-3"),
};
assertNull(dto.getProductContent());
assertFalse(dto.removeContent(contentEntities[0]));
assertFalse(dto.removeContent(contentEntities[1]));
assertFalse(dto.removeContent(contentEntities[2]));
dto.setProductContent(Arrays.asList(pcdata1, pcdata2));
boolean output = dto.removeContent(contentEntities[0]);
Collection<ProductContentData> output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata2), output2));
output = dto.removeContent(contentEntities[0]);
output2 = dto.getProductContent();
assertFalse(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata2), output2));
// This should work because we remove by content ID, not by exact element match
// Note that the collection should not be nulled by removing the final element
output = dto.removeContent(contentEntities[2]);
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Collections.<ProductContentData>emptyList(), output2));
}
@Test
public void testRemoveProductContentByDTO() {
ProductData dto = new ProductData();
ContentData[] content = new ContentData[] {
new ContentData("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new ContentData("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
new ContentData("c2", "content-3", "test_type", "test_label-3", "test_vendor-3"),
};
ProductContentData pcdata1 = new ProductContentData(content[0], true);
ProductContentData pcdata2 = new ProductContentData(content[1], false);
ProductContentData pcdata3 = new ProductContentData(content[2], false);
assertNull(dto.getProductContent());
assertFalse(dto.removeProductContent(pcdata1));
assertFalse(dto.removeProductContent(pcdata2));
assertFalse(dto.removeProductContent(pcdata3));
dto.setProductContent(Arrays.asList(pcdata1, pcdata2));
boolean output = dto.removeProductContent(pcdata1);
Collection<ProductContentData> output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata2), output2));
output = dto.removeProductContent(pcdata1);
output2 = dto.getProductContent();
assertFalse(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata2), output2));
// This should work because we remove by content ID, not by exact element match
// Note that the collection should not be nulled by removing the final element
output = dto.removeProductContent(pcdata3);
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Collections.<ProductContentData>emptyList(), output2));
}
@Test
public void testRemoveProductContentByEntity() {
ProductData dto = new ProductData();
ContentData[] content = new ContentData[] {
new ContentData("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new ContentData("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
};
ProductContentData pcdata1 = new ProductContentData(content[0], true);
ProductContentData pcdata2 = new ProductContentData(content[1], false);
Content[] contentEntities = new Content[] {
new Content("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new Content("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
new Content("c2", "content-3", "test_type", "test_label-3", "test_vendor-3"),
};
ProductContent pcentity1 = new ProductContent(null, contentEntities[0], true);
ProductContent pcentity2 = new ProductContent(null, contentEntities[1], false);
ProductContent pcentity3 = new ProductContent(null, contentEntities[2], true);
assertNull(dto.getProductContent());
assertFalse(dto.removeProductContent(pcentity1));
assertFalse(dto.removeProductContent(pcentity2));
assertFalse(dto.removeProductContent(pcentity3));
dto.setProductContent(Arrays.asList(pcdata1, pcdata2));
boolean output = dto.removeProductContent(pcentity1);
Collection<ProductContentData> output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata2), output2));
output = dto.removeProductContent(pcentity1);
output2 = dto.getProductContent();
assertFalse(output);
assertTrue(Util.collectionsAreEqual(Arrays.asList(pcdata2), output2));
// This should work because we remove by content ID, not by exact element match
// Note that the collection should not be nulled by removing the final element
output = dto.removeProductContent(pcentity3);
output2 = dto.getProductContent();
assertTrue(output);
assertTrue(Util.collectionsAreEqual(Collections.<ProductContentData>emptyList(), output2));
}
@Test
public void testGetSetDependentProductIds() {
ProductData dto = new ProductData();
Collection<String> input = Arrays.asList("1", "2", "3");
Collection<String> output = dto.getDependentProductIds();
assertNull(output);
ProductData output2 = dto.setDependentProductIds(input);
assertSame(dto, output2);
output = dto.getDependentProductIds();
assertTrue(Util.collectionsAreEqual(input, output));
}
@Test
public void testAddDependentProductId() {
ProductData dto = new ProductData();
Collection<String> pids = dto.getDependentProductIds();
assertNull(pids);
boolean output = dto.addDependentProductId("1");
pids = dto.getDependentProductIds();
assertTrue(output);
assertNotNull(pids);
assertTrue(Util.collectionsAreEqual(Arrays.asList("1"), pids));
output = dto.addDependentProductId("2");
pids = dto.getDependentProductIds();
assertTrue(output);
assertNotNull(pids);
assertTrue(Util.collectionsAreEqual(Arrays.asList("1", "2"), pids));
output = dto.addDependentProductId("1");
pids = dto.getDependentProductIds();
assertFalse(output);
assertNotNull(pids);
assertTrue(Util.collectionsAreEqual(Arrays.asList("1", "2"), pids));
}
@Test
public void testRemoveDependentProductId() {
ProductData dto = new ProductData();
Collection<String> pids = dto.getDependentProductIds();
assertNull(pids);
boolean output = dto.removeDependentProductId("1");
pids = dto.getDependentProductIds();
assertFalse(output);
assertNull(pids);
dto.setDependentProductIds(Arrays.asList("1", "2"));
pids = dto.getDependentProductIds();
assertNotNull(pids);
assertTrue(Util.collectionsAreEqual(Arrays.asList("1", "2"), pids));
output = dto.removeDependentProductId("1");
pids = dto.getDependentProductIds();
assertTrue(output);
assertNotNull(pids);
assertTrue(Util.collectionsAreEqual(Arrays.asList("2"), pids));
output = dto.removeDependentProductId("3");
pids = dto.getDependentProductIds();
assertFalse(output);
assertNotNull(pids);
assertTrue(Util.collectionsAreEqual(Arrays.asList("2"), pids));
output = dto.removeDependentProductId("2");
pids = dto.getDependentProductIds();
assertTrue(output);
assertNotNull(pids);
assertTrue(Util.collectionsAreEqual(Arrays.<String>asList(), pids));
}
@Test
public void testGetSetHref() {
ProductData dto = new ProductData();
String input = "test_value";
String output = dto.getHref();
assertNull(output);
ProductData output2 = dto.setHref(input);
assertSame(output2, dto);
output = dto.getHref();
assertEquals(input, output);
}
@Test
public void testGetSetLocked() {
ProductData dto = new ProductData();
Boolean input = Boolean.TRUE;
Boolean output = dto.isLocked();
assertNull(output);
ProductData output2 = dto.setLocked(input);
assertSame(output2, dto);
output = dto.isLocked();
assertEquals(input, output);
}
protected Object[][] getValuesForEqualityAndReplication() {
Map<String, String> attributes1 = new HashMap<String, String>();
attributes1.put("a1", "v1");
attributes1.put("a2", "v2");
attributes1.put("a3", "v3");
Map<String, String> attributes2 = new HashMap<String, String>();
attributes2.put("a4", "v4");
attributes2.put("a5", "v5");
attributes2.put("a6", "v6");
ContentData[] content = new ContentData[] {
new ContentData("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new ContentData("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
new ContentData("c3", "content-3", "test_type", "test_label-3", "test_vendor-3"),
new ContentData("c4", "content-4", "test_type", "test_label-4", "test_vendor-4"),
new ContentData("c5", "content-5", "test_type", "test_label-5", "test_vendor-5"),
new ContentData("c6", "content-6", "test_type", "test_label-6", "test_vendor-6")
};
Collection<ProductContentData> productContent1 = Arrays.asList(
new ProductContentData(content[0], true),
new ProductContentData(content[1], false),
new ProductContentData(content[2], true)
);
Collection<ProductContentData> productContent2 = Arrays.asList(
new ProductContentData(content[3], true),
new ProductContentData(content[4], false),
new ProductContentData(content[5], true)
);
return new Object[][] {
new Object[] { "Uuid", "test_value", "alt_value" },
new Object[] { "Id", "test_value", "alt_value" },
new Object[] { "Name", "test_value", "alt_value" },
new Object[] { "Multiplier", 1234L, 4567L },
new Object[] { "Attributes", attributes1, attributes2 },
new Object[] { "ProductContent", productContent1, productContent2 },
new Object[] { "DependentProductIds", Arrays.asList("1", "2", "3"), Arrays.asList("4", "5") },
// new Object[] { "Href", "test_value", null },
new Object[] { "Locked", Boolean.TRUE, false }
};
}
protected Method[] getAccessorAndMutator(String methodSuffix, Class mutatorInputClass)
throws Exception {
Method accessor = null;
Method mutator = null;
try {
accessor = ProductData.class.getDeclaredMethod("get" + methodSuffix, null);
}
catch (NoSuchMethodException e) {
accessor = ProductData.class.getDeclaredMethod("is" + methodSuffix, null);
}
try {
mutator = ProductData.class.getDeclaredMethod("set" + methodSuffix, mutatorInputClass);
}
catch (NoSuchMethodException e) {
if (Collection.class.isAssignableFrom(mutatorInputClass)) {
mutator = ProductData.class.getDeclaredMethod("set" + methodSuffix, Collection.class);
}
else if (Map.class.isAssignableFrom(mutatorInputClass)) {
mutator = ProductData.class.getDeclaredMethod("set" + methodSuffix, Map.class);
}
else {
throw e;
}
}
return new Method[] { accessor, mutator };
}
@Test
public void testBaseEquality() {
ProductData lhs = new ProductData();
ProductData rhs = new ProductData();
assertFalse(lhs.equals(null));
assertTrue(lhs.equals(lhs));
assertTrue(rhs.equals(rhs));
assertTrue(lhs.equals(rhs));
assertTrue(rhs.equals(lhs));
}
@Test
@Parameters(method = "getValuesForEqualityAndReplication")
public void testEquality(String valueName, Object value1, Object value2) throws Exception {
Method[] methods = this.getAccessorAndMutator(valueName, value1.getClass());
Method accessor = methods[0];
Method mutator = methods[1];
ProductData lhs = new ProductData();
ProductData rhs = new ProductData();
mutator.invoke(lhs, value1);
mutator.invoke(rhs, value1);
if (value1 instanceof Collection) {
assertTrue(Util.collectionsAreEqual(
(Collection) accessor.invoke(lhs), (Collection) accessor.invoke(rhs)
));
}
else {
assertEquals(accessor.invoke(lhs), accessor.invoke(rhs));
}
assertTrue(lhs.equals(rhs));
assertTrue(rhs.equals(lhs));
assertTrue(lhs.equals(lhs));
assertTrue(rhs.equals(rhs));
assertEquals(lhs.hashCode(), rhs.hashCode());
mutator.invoke(rhs, value2);
if (value2 instanceof Collection) {
assertFalse(Util.collectionsAreEqual(
(Collection) accessor.invoke(lhs), (Collection) accessor.invoke(rhs)
));
}
else {
assertNotEquals(accessor.invoke(lhs), accessor.invoke(rhs));
}
assertFalse(lhs.equals(rhs));
assertFalse(rhs.equals(lhs));
assertTrue(lhs.equals(lhs));
assertTrue(rhs.equals(rhs));
}
@Test
@Parameters(method = "getValuesForEqualityAndReplication")
public void testClone(String valueName, Object value1, Object value2) throws Exception {
Method[] methods = this.getAccessorAndMutator(valueName, value1.getClass());
Method accessor = methods[0];
Method mutator = methods[1];
ProductData base = new ProductData();
mutator.invoke(base, value1);
ProductData clone = (ProductData) base.clone();
if (value1 instanceof Collection) {
assertTrue(Util.collectionsAreEqual(
(Collection) accessor.invoke(base, null), (Collection) accessor.invoke(clone, null)
));
}
else {
assertEquals(accessor.invoke(base, null), accessor.invoke(clone, null));
}
assertEquals(base, clone);
assertEquals(base.hashCode(), clone.hashCode());
}
@Test
@Parameters(method = "getValuesForEqualityAndReplication")
public void testPopulateWithDTO(String valueName, Object value1, Object value2) throws Exception {
Method[] methods = this.getAccessorAndMutator(valueName, value1.getClass());
Method accessor = methods[0];
Method mutator = methods[1];
ProductData base = new ProductData();
ProductData source = new ProductData();
mutator.invoke(source, value1);
base.populate(source);
// Verify only the specified field was set
for (Method method : ProductData.class.getDeclaredMethods()) {
if (method.getName().matches("^(get|is)\\w+") && method.getParameterTypes().length == 0) {
Object output = method.invoke(base, null);
if (method.getName().equals(accessor.getName())) {
if (value1 instanceof Collection) {
assertTrue(output instanceof Collection);
assertTrue(Util.collectionsAreEqual((Collection) value1, (Collection) output));
}
else {
assertEquals(value1, output);
}
}
else {
assertNull(output);
}
}
}
}
protected Object[][] getValuesPopulationByEntity() {
Map<String, String> attributes = new HashMap<String, String>();
attributes.put("a1", "v1");
attributes.put("a2", "v2");
attributes.put("a3", "v3");
return new Object[][] {
new Object[] { "Uuid", "test_value", null },
new Object[] { "Id", "test_value", null },
new Object[] { "Name", "test_value", null },
new Object[] { "Multiplier", 1234L, null },
new Object[] { "Attributes", attributes, Collections.<String, String>emptyMap() },
// new Object[] { "ProductContent", productContent, Arrays.asList() },
new Object[] { "DependentProductIds", Arrays.asList("1", "2", "3"), Arrays.asList() },
// new Object[] { "Href", "test_value", null },
new Object[] { "Locked", Boolean.TRUE, false }
};
}
@Test
@Parameters(method = "getValuesPopulationByEntity")
public void testPopulateWithEntity(String valueName, Object input, Object defaultValue) throws Exception {
Method accessor = null;
Method mutator = null;
try {
accessor = ProductData.class.getDeclaredMethod("get" + valueName, null);
}
catch (NoSuchMethodException e) {
accessor = ProductData.class.getDeclaredMethod("is" + valueName, null);
}
try {
mutator = Product.class.getDeclaredMethod("set" + valueName, input.getClass());
}
catch (NoSuchMethodException e) {
if (Collection.class.isAssignableFrom(input.getClass())) {
mutator = Product.class.getDeclaredMethod("set" + valueName, Collection.class);
}
else if (Map.class.isAssignableFrom(input.getClass())) {
mutator = Product.class.getDeclaredMethod("set" + valueName, Map.class);
}
else if (Boolean.class.isAssignableFrom(input.getClass())) {
mutator = Product.class.getDeclaredMethod("set" + valueName, boolean.class);
}
else {
throw e;
}
}
ProductData base = new ProductData();
Product source = new Product();
mutator.invoke(source, input);
base.populate(source);
// Verify only the specified field was set
for (Method method : ProductData.class.getDeclaredMethods()) {
if (method.getName().matches("^(get|is)\\w+") && method.getParameterTypes().length == 0) {
Object output = method.invoke(base, null);
if (method.getName().equals(accessor.getName())) {
if (input instanceof Collection) {
assertTrue(output instanceof Collection);
assertTrue(Util.collectionsAreEqual((Collection) input, (Collection) output));
}
else {
assertEquals(input, output);
}
}
else {
for (Object[] values : this.getValuesPopulationByEntity()) {
if (method.getName().endsWith((String) values[0])) {
if (values[2] instanceof Collection) {
assertTrue(output instanceof Collection);
assertTrue(Util.collectionsAreEqual((Collection) values[2],
(Collection) output));
}
else {
assertEquals(values[2], output);
}
}
}
}
}
}
}
// These tests are for the values which have methods that don't conform as nicely as the
// others, so reflection gets too messy for a single test method.
@Test
public void testPopulateByEntityWithAttributes() {
ProductData base = new ProductData();
Product source = new Product();
Map<String, String> attributes1 = new HashMap<String, String>();
attributes1.put("a1", "v1");
attributes1.put("a2", "v2");
attributes1.put("a3", "v3");
source.setAttributes(attributes1);
// Verify base state
assertNull(base.getUuid());
assertNull(base.getId());
assertNull(base.getName());
assertNull(base.getMultiplier());
assertNull(base.getAttributes());
assertNull(base.getProductContent());
assertNull(base.getDependentProductIds());
assertNull(base.getHref());
assertNull(base.isLocked());
base.populate(source);
// Verify populated state
assertNull(base.getUuid());
assertNull(base.getId());
assertNull(base.getName());
assertNull(base.getMultiplier());
assertNull(base.getHref());
// Note: entities are always locked or unlocked, so this can never be null following a
// populate.
assertFalse(base.isLocked());
// Note: by default, entities have empty collections (NOT null, as was the case before
// DTOs). As a result, these will never be null after a populate.
assertNotNull(base.getProductContent());
assertTrue(base.getProductContent().isEmpty());
assertNotNull(base.getDependentProductIds());
assertTrue(base.getDependentProductIds().isEmpty());
assertNotNull(base.getAttributes());
assertEquals(attributes1, base.getAttributes());
}
@Test
public void testPopulateByEntityWithContent() {
ProductData base = new ProductData();
Product source = new Product();
Content[] contentEntities = new Content[] {
new Content("c1", "content-1", "test_type", "test_label-1", "test_vendor-1"),
new Content("c2", "content-2", "test_type", "test_label-2", "test_vendor-2"),
new Content("c3", "content-3", "test_type", "test_label-3", "test_vendor-3"),
};
ProductContent pcentity1 = new ProductContent(null, contentEntities[0], true);
ProductContent pcentity2 = new ProductContent(null, contentEntities[1], false);
ProductContent pcentity3 = new ProductContent(null, contentEntities[2], true);
ProductContentData pcdata1 = pcentity1.toDTO();
ProductContentData pcdata2 = pcentity2.toDTO();
ProductContentData pcdata3 = pcentity3.toDTO();
source.setProductContent(Arrays.asList(pcentity1, pcentity2, pcentity3));
// Verify base state
assertNull(base.getUuid());
assertNull(base.getId());
assertNull(base.getName());
assertNull(base.getMultiplier());
assertNull(base.getAttributes());
assertNull(base.getProductContent());
assertNull(base.getDependentProductIds());
assertNull(base.getHref());
assertNull(base.isLocked());
base.populate(source);
// Verify populated state
assertNull(base.getUuid());
assertNull(base.getId());
assertNull(base.getName());
assertNull(base.getMultiplier());
assertNull(base.getHref());
// Note: entities are always locked or unlocked, so this can never be null following a
// populate.
assertFalse(base.isLocked());
// Note: by default, entities have empty collections (NOT null, as was the case before
// DTOs). As a result, these will never be null after a populate.
assertNotNull(base.getAttributes());
assertTrue(base.getAttributes().isEmpty());
assertNotNull(base.getDependentProductIds());
assertTrue(base.getDependentProductIds().isEmpty());
assertNotNull(base.getProductContent());
assertTrue(Util.collectionsAreEqual(
Arrays.asList(pcdata1, pcdata2, pcdata3), base.getProductContent()
));
}
@Test
public void testPopulateByEntityWithUUID() {
ProductData base = new ProductData();
Product source = new Product();
String uuid = "test_uuid";
source.setUuid(uuid);
// Verify base state
assertNull(base.getUuid());
assertNull(base.getId());
assertNull(base.getName());
assertNull(base.getMultiplier());
assertNull(base.getAttributes());
assertNull(base.getProductContent());
assertNull(base.getDependentProductIds());
assertNull(base.getHref());
assertNull(base.isLocked());
base.populate(source);
// Verify populated state
assertNull(base.getId());
assertNull(base.getName());
assertNull(base.getMultiplier());
// Note: entities are always locked or unlocked, so this can never be null following a
// populate.
assertFalse(base.isLocked());
// Note: by default, entities have empty collections (NOT null, as was the case before
// DTOs). As a result, these will never be null after a populate.
assertNotNull(base.getAttributes());
assertTrue(base.getAttributes().isEmpty());
assertNotNull(base.getProductContent());
assertTrue(base.getProductContent().isEmpty());
assertNotNull(base.getDependentProductIds());
assertTrue(base.getDependentProductIds().isEmpty());
assertEquals(uuid, base.getUuid());
// Setting the UUID is the only way to influence the HREF from an entity. This should be
// reflected by a populate with an entity that has a UUID.
assertEquals("/products/" + uuid, base.getHref());
}
@Test
public void testProductAttributeJsonDeserializationV1() throws Exception {
String attributes = "\"attributes\": [ " +
" {" +
" \"name\" : \"attrib-1\"," +
" \"value\" : \"value-1\"," +
" \"created\" : \"2016-09-07T15:08:14+0000\"," +
" \"updated\" : \"2016-09-07T15:08:14+0000\"" +
" }," +
" {" +
" \"name\" : \"attrib-2\"," +
" \"value\" : \"value-2\"," +
" \"created\" : \"2016-09-07T15:08:14+0000\"," +
" \"updated\" : \"2016-09-07T15:08:14+0000\"" +
" }," +
" {" +
" \"name\" : 3," +
" \"value\" : 3," +
" \"created\" : \"2016-09-07T15:08:14+0000\"," +
" \"updated\" : \"2016-09-07T15:08:14+0000\"" +
" }]";
Map<String, String> expectedAttrib = new HashMap<String, String>();
expectedAttrib.put("attrib-1", "value-1");
expectedAttrib.put("attrib-2", "value-2");
expectedAttrib.put("3", "3");
ProductData dto = this.mapper.readValue(
PRODUCT_JSON_BASE + "," + attributes + "}", ProductData.class);
assertEquals(expectedAttrib, dto.getAttributes());
}
@Test
public void testProductAttributeJsonDeserializationV2() throws Exception {
String attributes = "\"attributes\": { " +
" \"attrib-1\": \"value-1\"," +
" \"attrib-2\": \"value-2\"," +
" \"attrib-3\": 3" +
"}";
Map<String, String> expectedAttrib = new HashMap<String, String>();
expectedAttrib.put("attrib-1", "value-1");
expectedAttrib.put("attrib-2", "value-2");
expectedAttrib.put("attrib-3", "3");
ProductData dto = this.mapper.readValue(
PRODUCT_JSON_BASE + "," + attributes + "}", ProductData.class);
assertEquals(expectedAttrib, dto.getAttributes());
}
@Test
public void testSerializeProductAttributes() throws Exception {
String expectedHeader = "\"attributes\":[{";
String expectedValue1 = "\"name\":\"attrib-1\",\"value\":\"value-1\"";
String expectedValue2 = "\"name\":\"attrib-2\",\"value\":\"value-2\"";
String expectedValue3 = "\"name\":\"attrib-3\",\"value\":\"3\"";
Map<String, String> attributes = new HashMap<String, String>();
attributes.put("attrib-1", "value-1");
attributes.put("attrib-2", "value-2");
attributes.put("attrib-3", "3");
ProductData dto = new ProductData();
dto.setAttributes(attributes);
String output = this.mapper.writeValueAsString(dto);
// Since the attributes are stored as a map, we can't guarantee any specific printed order.
// To deal with this, we separate the value and each header, then verify them individually.
assertTrue(output.contains(expectedHeader));
assertTrue(output.contains(expectedValue1));
assertTrue(output.contains(expectedValue2));
assertTrue(output.contains(expectedValue3));
}
}