Repository: incubator-atlas Updated Branches: refs/heads/master a52112d86 -> 2a441bec1
http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasClassificationType.java ---------------------------------------------------------------------- diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasClassificationType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasClassificationType.java new file mode 100644 index 0000000..fc2de25 --- /dev/null +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasClassificationType.java @@ -0,0 +1,125 @@ +/** + * 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.atlas.type; + +import java.util.*; + +import org.apache.atlas.exception.AtlasBaseException; +import org.apache.atlas.model.ModelTestUtil; +import org.apache.atlas.model.instance.AtlasClassification; +import org.apache.atlas.model.typedef.AtlasBaseTypeDef; +import org.apache.atlas.model.typedef.AtlasClassificationDef; +import org.testng.annotations.Test; + +import static org.testng.Assert.*; + + +public class TestAtlasClassificationType { + private final AtlasClassificationType classificationType; + private final List<Object> validValues = new ArrayList<Object>(); + private final List<Object> invalidValues = new ArrayList<Object>(); + + { + classificationType = getClassificationType(ModelTestUtil.getClassificationDefWithSuperTypes()); + + AtlasClassification invalidValue1 = classificationType.createDefaultValue(); + AtlasClassification invalidValue2 = classificationType.createDefaultValue(); + Map<String, Object> invalidValue3 = classificationType.createDefaultValue().getAttributes(); + + // invalid value for int + invalidValue1.setAttribute(ModelTestUtil.getDefaultAttributeName(AtlasBaseTypeDef.ATLAS_TYPE_INT), "xyz"); + // invalid value for date + invalidValue2.setAttribute(ModelTestUtil.getDefaultAttributeName(AtlasBaseTypeDef.ATLAS_TYPE_DATE), "xyz"); + // invalid value for bigint + invalidValue3.put(ModelTestUtil.getDefaultAttributeName(AtlasBaseTypeDef.ATLAS_TYPE_BIGINTEGER), "xyz"); + + validValues.add(null); + validValues.add(classificationType.createDefaultValue()); + validValues.add(classificationType.createDefaultValue().getAttributes()); // Map<String, Object> + invalidValues.add(invalidValue1); + invalidValues.add(invalidValue2); + invalidValues.add(invalidValue3); + invalidValues.add(new AtlasClassification()); // no values for mandatory attributes + invalidValues.add(new HashMap<Object, Object>()); // no values for mandatory attributes + invalidValues.add(1); // incorrect datatype + invalidValues.add(new HashSet()); // incorrect datatype + invalidValues.add(new ArrayList()); // incorrect datatype + invalidValues.add(new String[] {}); // incorrect datatype + } + + @Test + public void testClassificationTypeDefaultValue() { + AtlasClassification defValue = classificationType.createDefaultValue(); + + assertNotNull(defValue); + assertEquals(defValue.getTypeName(), classificationType.getTypeName()); + } + + @Test + public void testClassificationTypeIsValidValue() { + for (Object value : validValues) { + assertTrue(classificationType.isValidValue(value), "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(classificationType.isValidValue(value), "value=" + value); + } + } + + @Test + public void testClassificationTypeGetNormalizedValue() { + assertNull(classificationType.getNormalizedValue(null), "value=" + null); + + for (Object value : validValues) { + if (value == null) { + continue; + } + + Object normalizedValue = classificationType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + } + + for (Object value : invalidValues) { + assertNull(classificationType.getNormalizedValue(value), "value=" + value); + } + } + + @Test + public void testClassificationTypeValidateValue() { + List<String> messages = new ArrayList<String>(); + for (Object value : validValues) { + assertTrue(classificationType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(classificationType.validateValue(value, "testObj", messages)); + assertTrue(messages.size() > 0, "value=" + value); + messages.clear(); + } + } + + private static AtlasClassificationType getClassificationType(AtlasClassificationDef classificationDef) { + try { + return new AtlasClassificationType(classificationDef, ModelTestUtil.getTypesRegistry()); + } catch (AtlasBaseException excp) { + return null; + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasDateType.java ---------------------------------------------------------------------- diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasDateType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasDateType.java new file mode 100644 index 0000000..a28840a --- /dev/null +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasDateType.java @@ -0,0 +1,132 @@ +/** + * 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.atlas.type; + +import org.apache.atlas.model.typedef.AtlasBaseTypeDef; +import org.apache.atlas.type.AtlasBuiltInTypes.AtlasDateType; +import org.testng.annotations.Test; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.Date; +import java.util.ArrayList; +import java.util.List; + +import static org.testng.Assert.*; + + +public class TestAtlasDateType { + private final AtlasDateType dateType = new AtlasDateType(); + + private final Object[] validValues = { + null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1), + Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", + }; + + private final Object[] negativeValues = { + Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1), + Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1", + }; + + private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", }; + + private final Date now = new Date(); + private final String strNow = AtlasBaseTypeDef.DATE_FORMATTER.format(now); + + @Test + public void testDateTypeDefaultValue() { + Date defValue = dateType.createDefaultValue(); + + assertEquals(defValue, new Date(0)); + } + + @Test + public void testDateTypeIsValidValue() { + for (Object value : validValues) { + assertTrue(dateType.isValidValue(value), "value=" + value); + } + + assertTrue(dateType.isValidValue(now), "value=" + now); + assertTrue(dateType.isValidValue(strNow), "value=" + strNow); + + for (Object value : negativeValues) { + assertTrue(dateType.isValidValue(value), "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(dateType.isValidValue(value), "value=" + value); + } + } + + @Test + public void testDateTypeGetNormalizedValue() { + assertNull(dateType.getNormalizedValue(null), "value=" + null); + + for (Object value : validValues) { + if (value == null) { + continue; + } + + Date normalizedValue = dateType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, new Date(1), "value=" + value); + } + + assertNotNull(dateType.getNormalizedValue(now), "value=" + now); + assertEquals(dateType.getNormalizedValue(now), now, "value=" + now); + assertNotNull(dateType.getNormalizedValue(strNow), "value=" + strNow); + assertEquals(dateType.getNormalizedValue(now), now, "value=" + now); + + for (Object value : negativeValues) { + Date normalizedValue = dateType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, new Date(-1), "value=" + value); + } + + for (Object value : invalidValues) { + assertNull(dateType.getNormalizedValue(value), "value=" + value); + } + } + + @Test + public void testDateTypeValidateValue() { + List<String> messages = new ArrayList<String>(); + for (Object value : validValues) { + assertTrue(dateType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + assertTrue(dateType.validateValue(now, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + now); + assertTrue(dateType.validateValue(strNow, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + strNow); + + for (Object value : negativeValues) { + assertTrue(dateType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(dateType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 1, "value=" + value); + messages.clear(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasDoubleType.java ---------------------------------------------------------------------- diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasDoubleType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasDoubleType.java new file mode 100644 index 0000000..1b1e013 --- /dev/null +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasDoubleType.java @@ -0,0 +1,115 @@ +/** + * 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.atlas.type; + +import org.apache.atlas.type.AtlasBuiltInTypes.AtlasDoubleType; +import org.testng.annotations.Test; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + +import static org.testng.Assert.*; + + +public class TestAtlasDoubleType { + private final AtlasDoubleType doubleType = new AtlasDoubleType(); + + private final Object[] validValues = { + null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1), + Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", + }; + + private final Object[] negativeValues = { + Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1), + Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1", + }; + + private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", }; + + + @Test + public void testDoubleTypeDefaultValue() { + Double defValue = doubleType.createDefaultValue(); + + assertEquals(defValue, Double.valueOf(0)); + } + + @Test + public void testDoubleTypeIsValidValue() { + for (Object value : validValues) { + assertTrue(doubleType.isValidValue(value), "value=" + value); + } + + for (Object value : negativeValues) { + assertTrue(doubleType.isValidValue(value), "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(doubleType.isValidValue(value), "value=" + value); + } + } + + @Test + public void testDoubleTypeGetNormalizedValue() { + assertNull(doubleType.getNormalizedValue(null), "value=" + null); + + for (Object value : validValues) { + if (value == null) { + continue; + } + + Double normalizedValue = doubleType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, Double.valueOf(1), "value=" + value); + } + + for (Object value : negativeValues) { + Double normalizedValue = doubleType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, Double.valueOf(-1), "value=" + value); + } + + for (Object value : invalidValues) { + assertNull(doubleType.getNormalizedValue(value), "value=" + value); + } + } + + @Test + public void testDoubleTypeValidateValue() { + List<String> messages = new ArrayList<String>(); + for (Object value : validValues) { + assertTrue(doubleType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : negativeValues) { + assertTrue(doubleType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(doubleType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 1, "value=" + value); + messages.clear(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasEntityType.java ---------------------------------------------------------------------- diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasEntityType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasEntityType.java new file mode 100644 index 0000000..8139fd4 --- /dev/null +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasEntityType.java @@ -0,0 +1,125 @@ +/** + * 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.atlas.type; + +import java.util.*; + +import org.apache.atlas.exception.AtlasBaseException; +import org.apache.atlas.model.ModelTestUtil; +import org.apache.atlas.model.instance.AtlasEntity; +import org.apache.atlas.model.typedef.AtlasBaseTypeDef; +import org.apache.atlas.model.typedef.AtlasEntityDef; +import org.testng.annotations.Test; + +import static org.testng.Assert.*; + + +public class TestAtlasEntityType { + private final AtlasEntityType entityType; + private final List<Object> validValues = new ArrayList<Object>(); + private final List<Object> invalidValues = new ArrayList<Object>(); + + { + entityType = getEntityType(ModelTestUtil.getEntityDefWithSuperTypes()); + + AtlasEntity invalidValue1 = entityType.createDefaultValue(); + AtlasEntity invalidValue2 = entityType.createDefaultValue(); + Map<String, Object> invalidValue3 = entityType.createDefaultValue().getAttributes(); + + // invalid value for int + invalidValue1.setAttribute(ModelTestUtil.getDefaultAttributeName(AtlasBaseTypeDef.ATLAS_TYPE_INT), "xyz"); + // invalid value for date + invalidValue2.setAttribute(ModelTestUtil.getDefaultAttributeName(AtlasBaseTypeDef.ATLAS_TYPE_DATE), "xyz"); + // invalid value for bigint + invalidValue3.put(ModelTestUtil.getDefaultAttributeName(AtlasBaseTypeDef.ATLAS_TYPE_BIGINTEGER), "xyz"); + + validValues.add(null); + validValues.add(entityType.createDefaultValue()); + validValues.add(entityType.createDefaultValue().getAttributes()); // Map<String, Object> + invalidValues.add(invalidValue1); + invalidValues.add(invalidValue2); + invalidValues.add(invalidValue3); + invalidValues.add(new AtlasEntity()); // no values for mandatory attributes + invalidValues.add(new HashMap<Object, Object>()); // no values for mandatory attributes + invalidValues.add(1); // incorrect datatype + invalidValues.add(new HashSet()); // incorrect datatype + invalidValues.add(new ArrayList()); // incorrect datatype + invalidValues.add(new String[] {}); // incorrect datatype + } + + @Test + public void testEntityTypeDefaultValue() { + AtlasEntity defValue = entityType.createDefaultValue(); + + assertNotNull(defValue); + assertEquals(defValue.getTypeName(), entityType.getTypeName()); + } + + @Test + public void testEntityTypeIsValidValue() { + for (Object value : validValues) { + assertTrue(entityType.isValidValue(value), "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(entityType.isValidValue(value), "value=" + value); + } + } + + @Test + public void testEntityTypeGetNormalizedValue() { + assertNull(entityType.getNormalizedValue(null), "value=" + null); + + for (Object value : validValues) { + if (value == null) { + continue; + } + + Object normalizedValue = entityType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + } + + for (Object value : invalidValues) { + assertNull(entityType.getNormalizedValue(value), "value=" + value); + } + } + + @Test + public void testEntityTypeValidateValue() { + List<String> messages = new ArrayList<String>(); + for (Object value : validValues) { + assertTrue(entityType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(entityType.validateValue(value, "testObj", messages)); + assertTrue(messages.size() > 0, "value=" + value); + messages.clear(); + } + } + + private static AtlasEntityType getEntityType(AtlasEntityDef entityDef) { + try { + return new AtlasEntityType(entityDef, ModelTestUtil.getTypesRegistry()); + } catch (AtlasBaseException excp) { + return null; + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasFloatType.java ---------------------------------------------------------------------- diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasFloatType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasFloatType.java new file mode 100644 index 0000000..dbfcf1d --- /dev/null +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasFloatType.java @@ -0,0 +1,115 @@ +/** + * 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.atlas.type; + +import org.apache.atlas.type.AtlasBuiltInTypes.AtlasFloatType; +import org.testng.annotations.Test; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + +import static org.testng.Assert.*; + + +public class TestAtlasFloatType { + private final AtlasFloatType floatType = new AtlasFloatType(); + + private final Object[] validValues = { + null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1), + Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", + }; + + private final Object[] negativeValues = { + Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1), + Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1", + }; + + private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", }; + + + @Test + public void testFloatTypeDefaultValue() { + Float defValue = floatType.createDefaultValue(); + + assertEquals(defValue, Float.valueOf(0)); + } + + @Test + public void testFloatTypeIsValidValue() { + for (Object value : validValues) { + assertTrue(floatType.isValidValue(value), "value=" + value); + } + + for (Object value : negativeValues) { + assertTrue(floatType.isValidValue(value), "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(floatType.isValidValue(value), "value=" + value); + } + } + + @Test + public void testFloatTypeGetNormalizedValue() { + assertNull(floatType.getNormalizedValue(null), "value=" + null); + + for (Object value : validValues) { + if (value == null) { + continue; + } + + Float normalizedValue = floatType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, Float.valueOf(1), "value=" + value); + } + + for (Object value : negativeValues) { + Float normalizedValue = floatType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, Float.valueOf(-1), "value=" + value); + } + + for (Object value : invalidValues) { + assertNull(floatType.getNormalizedValue(value), "value=" + value); + } + } + + @Test + public void testFloatTypeValidateValue() { + List<String> messages = new ArrayList<String>(); + for (Object value : validValues) { + assertTrue(floatType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : negativeValues) { + assertTrue(floatType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(floatType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 1, "value=" + value); + messages.clear(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasIntType.java ---------------------------------------------------------------------- diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasIntType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasIntType.java new file mode 100644 index 0000000..f6f6041 --- /dev/null +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasIntType.java @@ -0,0 +1,115 @@ +/** + * 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.atlas.type; + +import org.apache.atlas.type.AtlasBuiltInTypes.AtlasIntType; +import org.testng.annotations.Test; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + +import static org.testng.Assert.*; + + +public class TestAtlasIntType { + private final AtlasIntType intType = new AtlasIntType(); + + private final Object[] validValues = { + null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1), + Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", + }; + + private final Object[] negativeValues = { + Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1), + Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1", + }; + + private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", }; + + + @Test + public void testIntTypeDefaultValue() { + Integer defValue = intType.createDefaultValue(); + + assertEquals(defValue, Integer.valueOf(0)); + } + + @Test + public void testIntTypeIsValidValue() { + for (Object value : validValues) { + assertTrue(intType.isValidValue(value), "value=" + value); + } + + for (Object value : negativeValues) { + assertTrue(intType.isValidValue(value), "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(intType.isValidValue(value), "value=" + value); + } + } + + @Test + public void testIntTypeGetNormalizedValue() { + assertNull(intType.getNormalizedValue(null), "value=" + null); + + for (Object value : validValues) { + if (value == null) { + continue; + } + + Integer normalizedValue = intType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, Integer.valueOf(1), "value=" + value); + } + + for (Object value : negativeValues) { + Integer normalizedValue = intType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, Integer.valueOf(-1), "value=" + value); + } + + for (Object value : invalidValues) { + assertNull(intType.getNormalizedValue(value), "value=" + value); + } + } + + @Test + public void testIntTypeValidateValue() { + List<String> messages = new ArrayList<String>(); + for (Object value : validValues) { + assertTrue(intType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : negativeValues) { + assertTrue(intType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(intType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 1, "value=" + value); + messages.clear(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasLongType.java ---------------------------------------------------------------------- diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasLongType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasLongType.java new file mode 100644 index 0000000..b9fb089 --- /dev/null +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasLongType.java @@ -0,0 +1,115 @@ +/** + * 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.atlas.type; + +import org.apache.atlas.type.AtlasBuiltInTypes.AtlasLongType; +import org.testng.annotations.Test; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + +import static org.testng.Assert.*; + + +public class TestAtlasLongType { + private final AtlasLongType longType = new AtlasLongType(); + + private final Object[] validValues = { + null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1), + Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", + }; + + private final Object[] negativeValues = { + Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1), + Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1", + }; + + private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", }; + + + @Test + public void testLongTypeDefaultValue() { + Long defValue = longType.createDefaultValue(); + + assertEquals(defValue, Long.valueOf(0)); + } + + @Test + public void testLongTypeIsValidValue() { + for (Object value : validValues) { + assertTrue(longType.isValidValue(value), "value=" + value); + } + + for (Object value : negativeValues) { + assertTrue(longType.isValidValue(value), "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(longType.isValidValue(value), "value=" + value); + } + } + + @Test + public void testLongTypeGetNormalizedValue() { + assertNull(longType.getNormalizedValue(null), "value=" + null); + + for (Object value : validValues) { + if (value == null) { + continue; + } + + Long normalizedValue = longType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, Long.valueOf(1), "value=" + value); + } + + for (Object value : negativeValues) { + Long normalizedValue = longType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, Long.valueOf(-1), "value=" + value); + } + + for (Object value : invalidValues) { + assertNull(longType.getNormalizedValue(value), "value=" + value); + } + } + + @Test + public void testLongTypeValidateValue() { + List<String> messages = new ArrayList<String>(); + for (Object value : validValues) { + assertTrue(longType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : negativeValues) { + assertTrue(longType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(longType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 1, "value=" + value); + messages.clear(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasMapType.java ---------------------------------------------------------------------- diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasMapType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasMapType.java new file mode 100644 index 0000000..6f75d54 --- /dev/null +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasMapType.java @@ -0,0 +1,116 @@ +/** + * 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.atlas.type; + +import org.apache.atlas.type.AtlasBuiltInTypes.AtlasIntType; +import org.testng.annotations.Test; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.testng.Assert.*; + + +public class TestAtlasMapType { + private final AtlasMapType intIntMapType = new AtlasMapType(new AtlasIntType(), new AtlasIntType()); + private final Object[] validValues; + private final Object[] invalidValues; + + { + Map<String, Integer> strIntMap = new HashMap<String, Integer>(); + Map<String, Double> strDoubleMap = new HashMap<String, Double>(); + Map<String, String> strStringMap = new HashMap<String, String>(); + Map<Integer, Integer> intIntMap = new HashMap<Integer, Integer>(); + Map<Object, Object> objObjMap = new HashMap<Object, Object>(); + Map<Object, Object> invObjObjMap1 = new HashMap<Object, Object>(); + Map<Object, Object> invObjObjMap2 = new HashMap<Object, Object>(); + + for (int i = 0; i < 10; i++) { + strIntMap.put(Integer.toString(i), i); + strDoubleMap.put(Integer.toString(i), Double.valueOf(i)); + strStringMap.put(Integer.toString(i), Integer.toString(i)); + intIntMap.put(i, i); + objObjMap.put(i, i); + } + + invObjObjMap1.put("xyz", "123"); // invalid key + invObjObjMap2.put("123", "xyz"); // invalid value + + validValues = new Object[] { + null, new HashMap<String, Integer>(), new HashMap<Object, Object>(), strIntMap, strDoubleMap, strStringMap, + intIntMap, objObjMap, + }; + + invalidValues = new Object[] { invObjObjMap1, invObjObjMap2, }; + } + + + @Test + public void testMapTypeDefaultValue() { + Map<Object, Object> defValue = intIntMapType.createDefaultValue(); + + assertEquals(defValue.size(), 1); + } + + @Test + public void testMapTypeIsValidValue() { + for (Object value : validValues) { + assertTrue(intIntMapType.isValidValue(value), "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(intIntMapType.isValidValue(value), "value=" + value); + } + } + + @Test + public void testMapTypeGetNormalizedValue() { + assertNull(intIntMapType.getNormalizedValue(null), "value=" + null); + + for (Object value : validValues) { + if (value == null) { + continue; + } + + Map<Object, Object> normalizedValue = intIntMapType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + } + + for (Object value : invalidValues) { + assertNull(intIntMapType.getNormalizedValue(value), "value=" + value); + } + } + + @Test + public void testMapTypeValidateValue() { + List<String> messages = new ArrayList<String>(); + for (Object value : validValues) { + assertTrue(intIntMapType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(intIntMapType.validateValue(value, "testObj", messages)); + assertTrue(messages.size() > 0, "value=" + value); + messages.clear(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasObjectIdType.java ---------------------------------------------------------------------- diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasObjectIdType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasObjectIdType.java new file mode 100644 index 0000000..61f9146 --- /dev/null +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasObjectIdType.java @@ -0,0 +1,122 @@ +/** + * 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.atlas.type; + +import org.apache.atlas.model.instance.AtlasObjectId; +import org.apache.atlas.type.AtlasBuiltInTypes.AtlasObjectIdType; +import org.testng.annotations.Test; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.testng.Assert.*; + + +public class TestAtlasObjectIdType { + private final AtlasObjectIdType objectIdType = new AtlasObjectIdType(); + private final Object[] validValues; + private final Object[] invalidValues; + + { + Map<String, String> objectId1 = new HashMap<String, String>(); + Map<Object, Object> objectId2 = new HashMap<Object, Object>(); + Map<Object, Object> objectId3 = new HashMap<Object, Object>(); + Map<Object, Object> objectId4 = new HashMap<Object, Object>(); + Map<Object, Object> objectId5 = new HashMap<Object, Object>(); + + objectId1.put(AtlasObjectId.KEY_TYPENAME, "testType"); + objectId1.put(AtlasObjectId.KEY_GUID, "guid-1234"); + objectId2.put(AtlasObjectId.KEY_TYPENAME, "testType"); + objectId2.put(AtlasObjectId.KEY_GUID, 1234); + objectId3.put(AtlasObjectId.KEY_TYPENAME, "testType"); // no guid + objectId4.put(AtlasObjectId.KEY_GUID, "guid-1234"); // no typeName + objectId4.put(AtlasObjectId.KEY_TYPENAME + "-invalid", "testType"); + objectId5.put(AtlasObjectId.KEY_GUID + "-invalid", "guid-1234"); + + + validValues = new Object[] { + null, objectId1, objectId2, new AtlasObjectId(), new AtlasObjectId("testType", "guid-1234"), }; + + invalidValues = new Object[] { + objectId3, objectId4, objectId5, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), + Long.valueOf(1L), Float.valueOf(1), Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", + "", "12ab", "abcd", "-12ab", + }; + } + + @Test + public void testObjectIdTypeDefaultValue() { + AtlasObjectId defValue = objectIdType.createDefaultValue(); + + assertNotNull(defValue); + } + + @Test + public void testObjectIdTypeIsValidValue() { + for (Object value : validValues) { + assertTrue(objectIdType.isValidValue(value), "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(objectIdType.isValidValue(value), "value=" + value); + } + } + + @Test + public void testObjectIdTypeGetNormalizedValue() { + assertNull(objectIdType.getNormalizedValue(null), "value=" + null); + + for (Object value : validValues) { + if (value == null) { + continue; + } + + AtlasObjectId normalizedValue = objectIdType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + + if (value instanceof AtlasObjectId) { + assertEquals(normalizedValue, value, "value=" + value); + } else if (value instanceof Map) { + assertEquals(normalizedValue.getTypeName(), ((Map)value).get(AtlasObjectId.KEY_TYPENAME).toString(), + "value=" + value); + assertEquals(normalizedValue.getGuid(), ((Map)value).get(AtlasObjectId.KEY_GUID).toString(), + "value=" + value); + } + } + } + + @Test + public void testObjectIdTypeValidateValue() { + List<String> messages = new ArrayList<String>(); + for (Object value : validValues) { + assertTrue(objectIdType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(objectIdType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 1, "value=" + value); + messages.clear(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java ---------------------------------------------------------------------- diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java new file mode 100644 index 0000000..a266305 --- /dev/null +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java @@ -0,0 +1,115 @@ +/** + * 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.atlas.type; + +import org.apache.atlas.type.AtlasBuiltInTypes.AtlasShortType; +import org.testng.annotations.Test; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + +import static org.testng.Assert.*; + + +public class TestAtlasShortType { + private final AtlasShortType shortType = new AtlasShortType(); + + private final Object[] validValues = { + null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1), + Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", + }; + + private final Object[] negativeValues = { + Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1), + Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1", + }; + + private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", }; + + + @Test + public void testShortTypeDefaultValue() { + Short defValue = shortType.createDefaultValue(); + + assertEquals(defValue, Short.valueOf((short)0)); + } + + @Test + public void testShortTypeIsValidValue() { + for (Object value : validValues) { + assertTrue(shortType.isValidValue(value), "value=" + value); + } + + for (Object value : negativeValues) { + assertTrue(shortType.isValidValue(value), "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(shortType.isValidValue(value), "value=" + value); + } + } + + @Test + public void testShortTypeGetNormalizedValue() { + assertNull(shortType.getNormalizedValue(null), "value=" + null); + + for (Object value : validValues) { + if (value == null) { + continue; + } + + Short normalizedValue = shortType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, Short.valueOf((short)1), "value=" + value); + } + + for (Object value : negativeValues) { + Short normalizedValue = shortType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, Short.valueOf((short)-1), "value=" + value); + } + + for (Object value : invalidValues) { + assertNull(shortType.getNormalizedValue(value), "value=" + value); + } + } + + @Test + public void testShortTypeValidateValue() { + List<String> messages = new ArrayList<String>(); + for (Object value : validValues) { + assertTrue(shortType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : negativeValues) { + assertTrue(shortType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(shortType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 1, "value=" + value); + messages.clear(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasStringType.java ---------------------------------------------------------------------- diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasStringType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasStringType.java new file mode 100644 index 0000000..c171d98 --- /dev/null +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasStringType.java @@ -0,0 +1,90 @@ +/** + * 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.atlas.type; + +import org.apache.atlas.type.AtlasBuiltInTypes.AtlasStringType; +import org.testng.annotations.Test; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + +import static org.testng.Assert.*; + + +public class TestAtlasStringType { + private final AtlasStringType stringType = new AtlasStringType(); + + private final Object[] validValues = { + null, Byte.valueOf((byte)1), Short.valueOf((short)1), Integer.valueOf(1), Long.valueOf(1L), Float.valueOf(1), + Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", "", "12ab", "abcd", "-12ab", + }; + + private final Object[] invalidValues = { }; + + + @Test + public void testStringTypeDefaultValue() { + String defValue = stringType.createDefaultValue(); + + assertEquals(defValue, ""); + } + + @Test + public void testStringTypeIsValidValue() { + for (Object value : validValues) { + assertTrue(stringType.isValidValue(value), "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(stringType.isValidValue(value), "value=" + value); + } + } + + @Test + public void testStringTypeGetNormalizedValue() { + assertNull(stringType.getNormalizedValue(null), "value=" + null); + + for (Object value : validValues) { + if (value == null) { + continue; + } + + String normalizedValue = stringType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + assertEquals(normalizedValue, value.toString(), "value=" + value); + } + } + + @Test + public void testStringTypeValidateValue() { + List<String> messages = new ArrayList<String>(); + for (Object value : validValues) { + assertTrue(stringType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(stringType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 1, "value=" + value); + messages.clear(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/intg/src/test/java/org/apache/atlas/type/TestAtlasStructType.java ---------------------------------------------------------------------- diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasStructType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasStructType.java new file mode 100644 index 0000000..1a15232 --- /dev/null +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasStructType.java @@ -0,0 +1,183 @@ +/** + * 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.atlas.type; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; + +import org.apache.atlas.exception.AtlasBaseException; +import org.apache.atlas.model.ModelTestUtil; +import org.apache.atlas.model.instance.AtlasStruct; +import static org.apache.atlas.model.typedef.AtlasBaseTypeDef.ATLAS_TYPE_INT; +import static org.apache.atlas.model.typedef.AtlasBaseTypeDef.ATLAS_TYPE_DATE; +import static org.apache.atlas.model.typedef.AtlasBaseTypeDef.ATLAS_TYPE_BIGINTEGER; + +import org.apache.atlas.model.typedef.AtlasStructDef; +import org.apache.atlas.model.typedef.AtlasStructDef.AtlasAttributeDef; +import org.apache.atlas.model.typedef.AtlasStructDef.AtlasAttributeDef.Cardinality; +import org.testng.annotations.Test; + +import static org.testng.Assert.*; + + +public class TestAtlasStructType { + private static final String MULTI_VAL_ATTR_NAME_MIN_MAX = "multiValMinMax"; + private static final String MULTI_VAL_ATTR_NAME_MIN = "multiValMin"; + private static final String MULTI_VAL_ATTR_NAME_MAX = "multiValMax"; + private static final int MULTI_VAL_ATTR_MIN_COUNT = 2; + private static final int MULTI_VAL_ATTR_MAX_COUNT = 5; + + private final AtlasStructType structType; + private final List<Object> validValues; + private final List<Object> invalidValues; + + { + AtlasAttributeDef multiValuedAttribMinMax = new AtlasAttributeDef(MULTI_VAL_ATTR_NAME_MIN_MAX, ATLAS_TYPE_INT); + AtlasAttributeDef multiValuedAttribMin = new AtlasAttributeDef(MULTI_VAL_ATTR_NAME_MIN, ATLAS_TYPE_INT); + AtlasAttributeDef multiValuedAttribMax = new AtlasAttributeDef(MULTI_VAL_ATTR_NAME_MAX, ATLAS_TYPE_INT); + + multiValuedAttribMinMax.setCardinality(Cardinality.LIST); + multiValuedAttribMinMax.setValuesMinCount(MULTI_VAL_ATTR_MIN_COUNT); + multiValuedAttribMinMax.setValuesMaxCount(MULTI_VAL_ATTR_MAX_COUNT); + + multiValuedAttribMinMax.setCardinality(Cardinality.SET); + multiValuedAttribMin.setValuesMinCount(MULTI_VAL_ATTR_MIN_COUNT); + + multiValuedAttribMinMax.setCardinality(Cardinality.LIST); + multiValuedAttribMax.setValuesMaxCount(MULTI_VAL_ATTR_MAX_COUNT); + + AtlasStructDef structDef = ModelTestUtil.newStructDef(); + + structDef.addAttribute(multiValuedAttribMinMax); + structDef.addAttribute(multiValuedAttribMin); + structDef.addAttribute(multiValuedAttribMax); + + structType = getStructType(structDef); + validValues = new ArrayList<Object>(); + invalidValues = new ArrayList<Object>(); + + AtlasStruct invalidValue1 = structType.createDefaultValue(); + AtlasStruct invalidValue2 = structType.createDefaultValue(); + AtlasStruct invalidValue3 = structType.createDefaultValue(); + AtlasStruct invalidValue4 = structType.createDefaultValue(); + AtlasStruct invalidValue5 = structType.createDefaultValue(); + AtlasStruct invalidValue6 = structType.createDefaultValue(); + AtlasStruct invalidValue7 = structType.createDefaultValue(); + + // invalid value for int + invalidValue1.setAttribute(ModelTestUtil.getDefaultAttributeName(ATLAS_TYPE_INT), "xyz"); + + // invalid value for date + invalidValue2.setAttribute(ModelTestUtil.getDefaultAttributeName(ATLAS_TYPE_DATE), "xyz"); + + // invalid value for bigint + invalidValue3.setAttribute(ModelTestUtil.getDefaultAttributeName(ATLAS_TYPE_BIGINTEGER), "xyz"); + + // minCount is less than required + invalidValue4.setAttribute(MULTI_VAL_ATTR_NAME_MIN_MAX, new Integer[] { 1 }); + + // maxCount is more than allowed + invalidValue5.setAttribute(MULTI_VAL_ATTR_NAME_MIN_MAX, new Integer[] { 1, 2, 3, 4, 5, 6 }); + + // minCount is less than required + invalidValue6.setAttribute(MULTI_VAL_ATTR_NAME_MIN, new Integer[] { }); + + // maxCount is more than allowed + invalidValue7.setAttribute(MULTI_VAL_ATTR_NAME_MAX, new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }); + + validValues.add(null); + validValues.add(structType.createDefaultValue()); + validValues.add(structType.createDefaultValue().getAttributes()); // Map<String, Object> + invalidValues.add(invalidValue1); + invalidValues.add(invalidValue2); + invalidValues.add(invalidValue3); + invalidValues.add(invalidValue4); + invalidValues.add(invalidValue5); + invalidValues.add(invalidValue6); + invalidValues.add(invalidValue7); + invalidValues.add(new AtlasStruct()); // no values for mandatory attributes + invalidValues.add(new HashMap<Object, Object>()); // no values for mandatory attributes + invalidValues.add(1); // incorrect datatype + invalidValues.add(new HashSet()); // incorrect datatype + invalidValues.add(new ArrayList()); // incorrect datatype + invalidValues.add(new String[] {}); // incorrect datatype + } + + @Test + public void testStructTypeDefaultValue() { + AtlasStruct defValue = structType.createDefaultValue(); + + assertNotNull(defValue); + assertEquals(defValue.getTypeName(), structType.getTypeName()); + } + + @Test + public void testStructTypeIsValidValue() { + for (Object value : validValues) { + assertTrue(structType.isValidValue(value), "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(structType.isValidValue(value), "value=" + value); + } + } + + @Test + public void testStructTypeGetNormalizedValue() { + assertNull(structType.getNormalizedValue(null), "value=" + null); + + for (Object value : validValues) { + if (value == null) { + continue; + } + + Object normalizedValue = structType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + } + + for (Object value : invalidValues) { + assertNull(structType.getNormalizedValue(value), "value=" + value); + } + } + + @Test + public void testStructTypeValidateValue() { + List<String> messages = new ArrayList<String>(); + for (Object value : validValues) { + assertTrue(structType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + + for (Object value : invalidValues) { + assertFalse(structType.validateValue(value, "testObj", messages)); + assertTrue(messages.size() > 0, "value=" + value); + messages.clear(); + } + } + + private static AtlasStructType getStructType(AtlasStructDef structDef) { + try { + return new AtlasStructType(structDef, ModelTestUtil.getTypesRegistry()); + } catch (AtlasBaseException excp) { + return null; + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/pom.xml ---------------------------------------------------------------------- diff --git a/pom.xml b/pom.xml index ac5b042..5f1285a 100755 --- a/pom.xml +++ b/pom.xml @@ -429,6 +429,7 @@ <javax.servlet.version>3.1.0</javax.servlet.version> <!-- Needed for hooks --> <aopalliance.version>1.0</aopalliance.version> + <codehaus.jackson.version>1.9.13</codehaus.jackson.version> <commons-conf.version>1.10</commons-conf.version> <commons-collections.version>3.2.2</commons-collections.version> <commons-logging.version>1.1.3</commons-logging.version> @@ -501,6 +502,7 @@ </profiles> <modules> + <module>intg</module> <module>common</module> <module>typesystem</module> <module>server-api</module> @@ -999,6 +1001,12 @@ <!-- atlas modules --> <dependency> <groupId>org.apache.atlas</groupId> + <artifactId>atlas-intg</artifactId> + <version>${project.version}</version> + </dependency> + + <dependency> + <groupId>org.apache.atlas</groupId> <artifactId>atlas-typesystem</artifactId> <version>${project.version}</version> </dependency> http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/release-log.txt ---------------------------------------------------------------------- diff --git a/release-log.txt b/release-log.txt index 9e185c7..85ceaa4 100644 --- a/release-log.txt +++ b/release-log.txt @@ -9,6 +9,7 @@ ATLAS-1060 Add composite indexes for exact match performance improvements for al ATLAS-1127 Modify creation and modification timestamps to Date instead of Long(sumasai) ALL CHANGES: +ATLAS-1171 Structured, high-level public APIs (mneethiraj via shwethags) ATLAS-247 Hive Column level lineage (rhbutani,svimal2106 via shwethags) ATLAS-1184 ReservedTypesRegistrar checks for existence of 1st class type (svimal2106 via shwethags) ATLAS-1199 Atlas UI not loading after fresh build due to jquery-asBreadcrumbs plugin upgrade (kevalbhatt via shwethags) http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/src/build/checkstyle.xml ---------------------------------------------------------------------- diff --git a/src/build/checkstyle.xml b/src/build/checkstyle.xml index b7b7711..5442317 100755 --- a/src/build/checkstyle.xml +++ b/src/build/checkstyle.xml @@ -115,7 +115,9 @@ <property name="max" value="120"/> </module> <module name="MethodLength"/> - <module name="ParameterNumber"/> + <module name="ParameterNumber"> + <property name="tokens" value="METHOD_DEF"/> + </module> <module name="OuterTypeNumber"/> <!-- Checks for whitespace --> http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/webapp/pom.xml ---------------------------------------------------------------------- diff --git a/webapp/pom.xml b/webapp/pom.xml index 5ef1a7f..8fe4b9b 100755 --- a/webapp/pom.xml +++ b/webapp/pom.xml @@ -125,6 +125,11 @@ </dependency> <dependency> + <groupId>org.apache.atlas</groupId> + <artifactId>atlas-intg</artifactId> + </dependency> + + <dependency> <groupId>org.apache.hadoop</groupId> <artifactId>hadoop-common</artifactId> </dependency> http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/698a5652/webapp/src/main/java/org/apache/atlas/web/rest/TypesREST.java ---------------------------------------------------------------------- diff --git a/webapp/src/main/java/org/apache/atlas/web/rest/TypesREST.java b/webapp/src/main/java/org/apache/atlas/web/rest/TypesREST.java new file mode 100644 index 0000000..42cfd42 --- /dev/null +++ b/webapp/src/main/java/org/apache/atlas/web/rest/TypesREST.java @@ -0,0 +1,371 @@ +/** + * 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.atlas.web.rest; + +import javax.servlet.http.HttpServletRequest; +import javax.ws.rs.DELETE; +import javax.ws.rs.GET; +import javax.ws.rs.POST; +import javax.ws.rs.PUT; +import javax.ws.rs.Path; +import javax.ws.rs.PathParam; +import javax.ws.rs.Produces; +import javax.ws.rs.core.Context; + +import org.apache.atlas.api.PList; +import org.apache.atlas.api.SearchFilter; +import org.apache.atlas.model.typedef.AtlasClassificationDef; +import org.apache.atlas.model.typedef.AtlasEntityDef; +import org.apache.atlas.model.typedef.AtlasEnumDef; +import org.apache.atlas.model.typedef.AtlasStructDef; +import org.apache.atlas.web.util.Servlets; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + +@Path("types") +public class TypesREST { + private static final Logger LOG = LoggerFactory.getLogger(TypesREST.class); + + @POST + @Path("/enumdef") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasEnumDef createEnumDef(AtlasEnumDef enumDef) throws Exception { + AtlasEnumDef ret = null; + + // TODO: ret = store.createEnumDef() + + return ret; + } + + @GET + @Path("/enumdef/name/{name}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasEnumDef getEnumDefByName(@PathParam("name") String name) throws Exception { + AtlasEnumDef ret = null; + + // TODO: ret = store.getEnumDefByName(name) + + return ret; + } + + @GET + @Path("/enumdef/guid/{guid}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasEnumDef getEnumDefByGuid(@PathParam("guid") String guid) throws Exception { + AtlasEnumDef ret = null; + + // TODO: ret = store.getEnumDefByGuid(guid) + + return ret; + } + + @PUT + @Path("/enumdef/name/{name}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasEnumDef updateEnumDefByName(@PathParam("name") String name, AtlasEnumDef enumDef) throws Exception { + AtlasEnumDef ret = null; + + // TODO: ret = store.updateEnumDefByName(name, enumDef) + + return ret; + } + + @PUT + @Path("/enumdef/guid/{guid}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasEnumDef updateEnumDefByGuid(@PathParam("guid") String guid, AtlasEnumDef enumDef) throws Exception { + AtlasEnumDef ret = null; + + // TODO: ret = store.updateEnumDefByGuid(guid, enumDef) + + return ret; + } + + @DELETE + @Path("/enumdef/name/{name}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public void deleteEnumDefByName(@PathParam("name") String name) throws Exception { + // TODO: store.deleteEnumDefByName(name) + } + + @DELETE + @Path("/enumdef/guid/{guid}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public void deleteEnumDefByGuid(@PathParam("guid") String guid) throws Exception { + // TODO: store.deleteEnumDefByGuid(guid) + } + + @GET + @Path("/enumdef") + @Produces(Servlets.JSON_MEDIA_TYPE) + public PList<AtlasEnumDef> searchEnumDefs(@Context HttpServletRequest request) throws Exception { + PList<AtlasEnumDef> ret = null; + + // TODO: SearchFilter filter = getSearchFilter(request); + // TODO: ret = store.searchEnumDefs(filter); + + return ret; + } + + + @POST + @Path("/structdef") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasStructDef createStructDef(AtlasStructDef structDef) throws Exception { + AtlasStructDef ret = null; + + // TODO: ret = store.createStructDef() + + return ret; + } + + @GET + @Path("/structdef/name/{name}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasStructDef getStructDefByName(@PathParam("name") String name) throws Exception { + AtlasStructDef ret = null; + + // TODO: ret = store.getStructDefByName(name) + + return ret; + } + + @GET + @Path("/structdef/guid/{guid}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasStructDef getStructDefByGuid(@PathParam("guid") String guid) throws Exception { + AtlasStructDef ret = null; + + // TODO: ret = store.getStructDefByGuid(guid) + + return ret; + } + + @PUT + @Path("/structdef/name/{name}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasStructDef updateStructDefByName(@PathParam("name") String name, AtlasStructDef structDef) throws Exception { + AtlasStructDef ret = null; + + // TODO: ret = store.updateStructDefByName(name, structDef) + + return ret; + } + + @PUT + @Path("/structdef/guid/{guid}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasStructDef updateStructDefByGuid(@PathParam("guid") String guid, AtlasStructDef structDef) throws Exception { + AtlasStructDef ret = null; + + // TODO: ret = store.updateStructDefByGuid(guid, structDef) + + return ret; + } + + @DELETE + @Path("/structdef/name/{name}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public void deleteStructDefByName(@PathParam("name") String name) throws Exception { + // TODO: store.deleteStructDefByName(name) + } + + @DELETE + @Path("/structdef/guid/{guid}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public void deleteStructDefByGuid(@PathParam("guid") String guid) throws Exception { + // TODO: store.deleteStructDefByGuid(guid) + } + + @GET + @Path("/structdef") + @Produces(Servlets.JSON_MEDIA_TYPE) + public PList<AtlasStructDef> searchStructDefs(@Context HttpServletRequest request) throws Exception { + PList<AtlasStructDef> ret = null; + + // TODO: SearchFilter filter = getSearchFilter(request); + // TODO: ret = store.searchStructDefs(filter); + + return ret; + } + + + @POST + @Path("/classificationdef") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasClassificationDef createClassificationDef(AtlasClassificationDef classificationDef) throws Exception { + AtlasClassificationDef ret = null; + + // TODO: ret = store.createClassificationDef() + + return ret; + } + + @GET + @Path("/classificationdef/name/{name}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasClassificationDef getClassificationDefByName(@PathParam("name") String name) throws Exception { + AtlasClassificationDef ret = null; + + // TODO: ret = store.getClassificationDefByName(name) + + return ret; + } + + @GET + @Path("/classificationdef/guid/{guid}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasClassificationDef getClassificationDefByGuid(@PathParam("guid") String guid) throws Exception { + AtlasClassificationDef ret = null; + + // TODO: ret = store.getClassificationDefByGuid(guid) + + return ret; + } + + @PUT + @Path("/classificationdef/name/{name}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasClassificationDef updateClassificationDefByName(@PathParam("name") String name, AtlasClassificationDef classificationDef) throws Exception { + AtlasClassificationDef ret = null; + + // TODO: ret = store.updateClassificationDefByName(name, classificationDef) + + return ret; + } + + @PUT + @Path("/classificationdef/guid/{guid}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasClassificationDef updateClassificationDefByGuid(@PathParam("guid") String guid, AtlasClassificationDef classificationDef) throws Exception { + AtlasClassificationDef ret = null; + + // TODO: ret = store.updateClassificationDefByGuid(guid, classificationDef) + + return ret; + } + + @DELETE + @Path("/classificationdef/name/{name}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public void deleteClassificationDefByName(@PathParam("name") String name) throws Exception { + // TODO: store.deleteClassificationDefByName(name) + } + + @DELETE + @Path("/classificationdef/guid/{guid}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public void deleteClassificationDefByGuid(@PathParam("guid") String guid) throws Exception { + // TODO: store.deleteClassificationDefByGuid(guid) + } + + @GET + @Path("/classificationdef") + @Produces(Servlets.JSON_MEDIA_TYPE) + public PList<AtlasClassificationDef> searchClassificationDefs(SearchFilter filter) throws Exception { + PList<AtlasClassificationDef> ret = null; + + // TODO: SearchFilter filter = getSearchFilter(request); + // TODO: ret = store.searchClassificationDefs(filter); + + return ret; + } + + + @POST + @Path("/entitydef") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasEntityDef createEntityDef(AtlasEntityDef entityDef) throws Exception { + AtlasEntityDef ret = null; + + // TODO: ret = store.createEntityDef() + + return ret; + } + + @GET + @Path("/entitydef/name/{name}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasEntityDef getEntityDefByName(@PathParam("name") String name) throws Exception { + AtlasEntityDef ret = null; + + // TODO: ret = store.getEntityDefByName(name) + + return ret; + } + + @GET + @Path("/entitydef/guid/{guid}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasEntityDef getEntityDefByIdByGuid(@PathParam("guid") String guid) throws Exception { + AtlasEntityDef ret = null; + + // TODO: ret = store.getEntityDefByGuid(guid) + + return ret; + } + + @PUT + @Path("/entitydef/name/{name}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasEntityDef updateEntityDefByName(@PathParam("name") String name, AtlasEntityDef entityDef) throws Exception { + AtlasEntityDef ret = null; + + // TODO: ret = store.updateEntityDefByName(name, entityDef) + + return ret; + } + + @PUT + @Path("/entitydef/guid/{guid}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public AtlasEntityDef updateEntityDefByGuid(@PathParam("guid") String guid, AtlasEntityDef entityDef) throws Exception { + AtlasEntityDef ret = null; + + // TODO: ret = store.updateEntityDefByGuid(guid, entityDef) + + return ret; + } + + @DELETE + @Path("/entitydef/name/{name}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public void deleteEntityDef(@PathParam("name") String name) throws Exception { + // TODO: store.deleteEntityDefByName(name) + } + + @DELETE + @Path("/entitydef/guid/{guid}") + @Produces(Servlets.JSON_MEDIA_TYPE) + public void deleteEntityDefByGuid(@PathParam("guid") String guid) throws Exception { + // TODO: store.deleteEntityDefByGuid(guid) + } + + @GET + @Path("/entitydef") + @Produces(Servlets.JSON_MEDIA_TYPE) + public PList<AtlasEntityDef> searchEntityDefs(SearchFilter filter) throws Exception { + PList<AtlasEntityDef> ret = null; + + // TODO: SearchFilter filter = getSearchFilter(request); + // TODO: ret = store.searchEntityDefs(filter); + + return ret; + } +}
