/*******************************************************************************
 * Copyright (c) 2011 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0, which accompanies this distribution
 * and is available at http://www.eclipse.org/legal/epl-v10.html.
 * 
 * Contributors:
 *     Oracle - initial API and implementation
 ******************************************************************************/
package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.orm;

import java.util.Iterator;
import java.util.ListIterator;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jpt.common.core.tests.internal.projects.TestJavaProject.SourceWriter;
import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
import org.eclipse.jpt.jpa.core.MappingKeys;
import org.eclipse.jpt.jpa.core.context.InheritanceType;
import org.eclipse.jpt.jpa.core.context.orm.OrmPersistenceUnitMetadata;
import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentType;
import org.eclipse.jpt.jpa.core.resource.java.JPA;
import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkEntity;
import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkMultitenantType2_3;
import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkEntityMappings;
import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkPersistenceUnitDefaults;
import org.eclipse.jpt.jpa.eclipselink.core.context.orm.OrmEclipseLinkEntity;
import org.eclipse.jpt.jpa.eclipselink.core.context.orm.OrmEclipseLinkMappedSuperclass;
import org.eclipse.jpt.jpa.eclipselink.core.context.orm.OrmEclipseLinkMultitenancy2_3;
import org.eclipse.jpt.jpa.eclipselink.core.context.orm.OrmTenantDiscriminatorColumn2_3;
import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLink;
import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.EclipseLinkOrmFactory;
import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlMultitenant;
import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlMultitenantHolder;
import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.v2_3.MultitenantType;
import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink2_3ContextModelTestCase;

@SuppressWarnings("nls")
public class EclipseLink2_3OrmMultitenancyTests
	extends EclipseLink2_3ContextModelTestCase
{
	protected static final String SUB_TYPE_NAME = "AnnotationTestTypeChild";
	protected static final String FULLY_QUALIFIED_SUB_TYPE_NAME = PACKAGE_NAME + "." + SUB_TYPE_NAME;


	public EclipseLink2_3OrmMultitenancyTests(String name) {
		super(name);
	}

	private ICompilationUnit createTestEntity() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(JPA.ENTITY, JPA.ID);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@Entity");
			}
		});
	}

	private ICompilationUnit createTestMultitenantMappedSuperclass() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(
					JPA.MAPPED_SUPERCLASS,
					EclipseLink.MULTITENANT,
					EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@MappedSuperclass").append(CR);
				sb.append("@Multitenant").append(CR);
				sb.append("@TenantDiscriminatorColumn(name=\"MS_TENANT_ID\")").append(CR);
			}
		});
	}

	private ICompilationUnit createTestMultitenantRootEntity() throws Exception {
		return this.createTestType(new DefaultAnnotationWriter() {
			@Override
			public Iterator<String> imports() {
				return new ArrayIterator<String>(
					JPA.ENTITY,
					JPA.INHERITANCE,
					EclipseLink.MULTITENANT,
					EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
			}
			@Override
			public void appendTypeAnnotationTo(StringBuilder sb) {
				sb.append("@Entity").append(CR);
				sb.append("@Inheritenace").append(CR);
				sb.append("@Multitenant").append(CR);
				sb.append("@TenantDiscriminatorColumn(name=\"ROOT_ENTITY_TENANT_ID\")").append(CR);
			}
		});
	}

	private void createTestSubType() throws Exception {
		SourceWriter sourceWriter = new SourceWriter() {
			public void appendSourceTo(StringBuilder sb) {
				sb.append(CR);
					sb.append("import ");
					sb.append(JPA.ENTITY);
					sb.append(";");
					sb.append(CR);
				sb.append("@Entity");
				sb.append(CR);
				sb.append("public class ").append("AnnotationTestTypeChild").append(" ");
				sb.append("extends " + TYPE_NAME + " ");
				sb.append("{}").append(CR);
			}
		};
		this.javaProject.createCompilationUnit(PACKAGE_NAME, "AnnotationTestTypeChild.java", sourceWriter);
	}

	public void testUpdateSpecifiedType() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.foo");
		XmlMultitenantHolder multitenantHolder = (XmlMultitenantHolder) getXmlEntityMappings().getEntities().get(0);
		multitenantHolder.setMultitenant(EclipseLinkOrmFactory.eINSTANCE.createXmlMultitenant());

		OrmEclipseLinkMultitenancy2_3 ormMultitenancy = ((OrmEclipseLinkEntity) ormPersistentType.getMapping()).getMultitenancy();
		XmlMultitenant multitenantResource = multitenantHolder.getMultitenant();
		assertNull(ormMultitenancy.getSpecifiedType());
		assertNull(multitenantResource.getType());

		//set type in the resource model, verify context model updated
		multitenantResource.setType(MultitenantType.SINGLE_TABLE);
		assertEquals(EclipseLinkMultitenantType2_3.SINGLE_TABLE, ormMultitenancy.getSpecifiedType());
		assertEquals(MultitenantType.SINGLE_TABLE, multitenantResource.getType());

		//set type to null in the resource model
		multitenantResource.setType(null);
		assertNull(ormMultitenancy.getSpecifiedType());
		assertNull(multitenantResource.getType());

		multitenantResource.setType(MultitenantType.TABLE_PER_TENANT);
		assertEquals(EclipseLinkMultitenantType2_3.TABLE_PER_TENANT, ormMultitenancy.getSpecifiedType());
		assertEquals(MultitenantType.TABLE_PER_TENANT, multitenantResource.getType());

		multitenantHolder.setMultitenant(null);
		assertNull(ormMultitenancy.getSpecifiedType());
		assertNull(ormMultitenancy.getType());
		assertNull(multitenantHolder.getMultitenant());
	}

	public void testModifySpecifiedType() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.foo");
		XmlMultitenantHolder multitenantHolder = (XmlMultitenantHolder) getXmlEntityMappings().getEntities().get(0);
		multitenantHolder.setMultitenant(EclipseLinkOrmFactory.eINSTANCE.createXmlMultitenant());

		OrmEclipseLinkMultitenancy2_3 ormMultitenancy = ((OrmEclipseLinkEntity) ormPersistentType.getMapping()).getMultitenancy();
		XmlMultitenant multitenantResource = multitenantHolder.getMultitenant();
		assertNull(ormMultitenancy.getSpecifiedType());
		assertNull(multitenantResource.getType());

		//set type in the context model, verify resource model modified
		ormMultitenancy.setSpecifiedType(EclipseLinkMultitenantType2_3.SINGLE_TABLE);
		assertEquals(EclipseLinkMultitenantType2_3.SINGLE_TABLE, ormMultitenancy.getSpecifiedType());
		assertEquals(MultitenantType.SINGLE_TABLE, multitenantResource.getType());

		//set type to null in the context model
		ormMultitenancy.setSpecifiedType(null);
		assertNull(ormMultitenancy.getSpecifiedType());
		assertNull(multitenantResource.getType());	
	}

//	public void testUpdateSpecifiedIncludeCriteria() throws Exception {
//		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.foo");
//		XmlMultitenantHolder multitenantHolder = (XmlMultitenantHolder) getXmlEntityMappings().getEntities().get(0);
//		multitenantHolder.setMultitenant(EclipseLinkOrmFactory.eINSTANCE.createXmlMultitenant());
//
//		OrmEclipseLinkMultitenancy2_3 ormMultitenancy = ((OrmEclipseLinkEntity) ormPersistentType.getMapping()).getMultitenancy();
//		XmlMultitenant multitenantResource = multitenantHolder.getMultitenant();
//
//		assertNull(ormMultitenancy.getSpecifiedIncludeCriteria());
//		assertNull(multitenantResource.getIncludeCriteria());
//
//		//set enumerated in the resource model, verify context model updated
//		multitenantResource.setIncludeCriteria(Boolean.TRUE);
//		assertEquals(Boolean.TRUE, ormMultitenancy.getSpecifiedIncludeCriteria());
//		assertEquals(Boolean.TRUE, multitenantResource.getIncludeCriteria());
//
//		multitenantResource.setIncludeCriteria(Boolean.FALSE);
//		assertEquals(Boolean.FALSE, ormMultitenancy.getSpecifiedIncludeCriteria());
//		assertEquals(Boolean.FALSE, multitenantResource.getIncludeCriteria());
//
//		//set enumerated to null in the resource model
//		multitenantResource.setIncludeCriteria(null);
//		assertNull(ormMultitenancy.getSpecifiedIncludeCriteria());
//		assertNull(multitenantResource.getIncludeCriteria());
//	}
//
//	public void testModifySpecifiedIncludeCriteria() throws Exception {
//		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.foo");
//		XmlMultitenantHolder multitenantHolder = (XmlMultitenantHolder) getXmlEntityMappings().getEntities().get(0);
//		multitenantHolder.setMultitenant(EclipseLinkOrmFactory.eINSTANCE.createXmlMultitenant());
//
//		OrmEclipseLinkMultitenancy2_3 ormMultitenancy = ((OrmEclipseLinkEntity) ormPersistentType.getMapping()).getMultitenancy();
//		XmlMultitenant multitenantResource = multitenantHolder.getMultitenant();
//
//		assertNull(ormMultitenancy.getSpecifiedIncludeCriteria());
//		assertNull(multitenantResource.getIncludeCriteria());
//
//		//set enumerated in the context model, verify resource model updated
//		ormMultitenancy.setSpecifiedIncludeCriteria(Boolean.TRUE);
//		assertEquals(Boolean.TRUE, multitenantResource.getIncludeCriteria());
//		assertEquals(Boolean.TRUE, ormMultitenancy.getSpecifiedIncludeCriteria());
//
//		ormMultitenancy.setSpecifiedIncludeCriteria(Boolean.FALSE);
//		assertEquals(Boolean.FALSE, multitenantResource.getIncludeCriteria());
//		assertEquals(Boolean.FALSE, ormMultitenancy.getSpecifiedIncludeCriteria());
//
//		//set enumerated to null in the context model
//		ormMultitenancy.setSpecifiedIncludeCriteria(null);
//		assertNull(multitenantResource.getIncludeCriteria());
//		assertNull(ormMultitenancy.getSpecifiedIncludeCriteria());
//	}

	public void testAddSpecifiedTenantDiscriminatorColumn() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.foo");
		XmlMultitenantHolder multitenantHolder = (XmlMultitenantHolder) getXmlEntityMappings().getEntities().get(0);
		multitenantHolder.setMultitenant(EclipseLinkOrmFactory.eINSTANCE.createXmlMultitenant());

		OrmEclipseLinkMultitenancy2_3 ormMultitenancy = ((OrmEclipseLinkEntity) ormPersistentType.getMapping()).getMultitenancy();
		XmlMultitenant multitenantResource = multitenantHolder.getMultitenant();

		OrmTenantDiscriminatorColumn2_3 tenantDiscriminatorColumn = ormMultitenancy.addSpecifiedTenantDiscriminatorColumn(0);
		tenantDiscriminatorColumn.setSpecifiedName("FOO");

		assertEquals("FOO", multitenantResource.getTenantDiscriminatorColumns().get(0).getName());

		OrmTenantDiscriminatorColumn2_3 tenantDiscriminatorColumn2 = ormMultitenancy.addSpecifiedTenantDiscriminatorColumn(0);
		tenantDiscriminatorColumn2.setSpecifiedName("BAR");

		assertEquals("BAR", multitenantResource.getTenantDiscriminatorColumns().get(0).getName());
		assertEquals("FOO", multitenantResource.getTenantDiscriminatorColumns().get(1).getName());

		OrmTenantDiscriminatorColumn2_3 tenantDiscriminatorColumn3 = ormMultitenancy.addSpecifiedTenantDiscriminatorColumn(1);
		tenantDiscriminatorColumn3.setSpecifiedName("BAZ");

		assertEquals("BAR", multitenantResource.getTenantDiscriminatorColumns().get(0).getName());
		assertEquals("BAZ", multitenantResource.getTenantDiscriminatorColumns().get(1).getName());
		assertEquals("FOO", multitenantResource.getTenantDiscriminatorColumns().get(2).getName());

		ListIterator<OrmTenantDiscriminatorColumn2_3> tenantDiscriminatorColumns = ormMultitenancy.getSpecifiedTenantDiscriminatorColumns().iterator();
		assertEquals(tenantDiscriminatorColumn2, tenantDiscriminatorColumns.next());
		assertEquals(tenantDiscriminatorColumn3, tenantDiscriminatorColumns.next());
		assertEquals(tenantDiscriminatorColumn, tenantDiscriminatorColumns.next());

		tenantDiscriminatorColumns = ormMultitenancy.getSpecifiedTenantDiscriminatorColumns().iterator();
		assertEquals("BAR", tenantDiscriminatorColumns.next().getName());
		assertEquals("BAZ", tenantDiscriminatorColumns.next().getName());
		assertEquals("FOO", tenantDiscriminatorColumns.next().getName());
	}

	public void testRemoveSpecifiedTenantDiscriminatorColumn() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.foo");
		XmlMultitenantHolder multitenantHolder = (XmlMultitenantHolder) getXmlEntityMappings().getEntities().get(0);
		multitenantHolder.setMultitenant(EclipseLinkOrmFactory.eINSTANCE.createXmlMultitenant());

		OrmEclipseLinkMultitenancy2_3 ormMultitenancy = ((OrmEclipseLinkEntity) ormPersistentType.getMapping()).getMultitenancy();
		XmlMultitenant multitenantResource = multitenantHolder.getMultitenant();

		ormMultitenancy.addSpecifiedTenantDiscriminatorColumn(0).setSpecifiedName("FOO");
		ormMultitenancy.addSpecifiedTenantDiscriminatorColumn(1).setSpecifiedName("BAR");
		ormMultitenancy.addSpecifiedTenantDiscriminatorColumn(2).setSpecifiedName("BAZ");

		assertEquals(3, multitenantResource.getTenantDiscriminatorColumns().size());

		ormMultitenancy.removeSpecifiedTenantDiscriminatorColumn(0);
		assertEquals(2, multitenantResource.getTenantDiscriminatorColumns().size());
		assertEquals("BAR", multitenantResource.getTenantDiscriminatorColumns().get(0).getName());
		assertEquals("BAZ", multitenantResource.getTenantDiscriminatorColumns().get(1).getName());

		ormMultitenancy.removeSpecifiedTenantDiscriminatorColumn(0);
		assertEquals(1, multitenantResource.getTenantDiscriminatorColumns().size());
		assertEquals("BAZ", multitenantResource.getTenantDiscriminatorColumns().get(0).getName());

		ormMultitenancy.removeSpecifiedTenantDiscriminatorColumn(0);
		assertEquals(0, multitenantResource.getTenantDiscriminatorColumns().size());
	}

	public void testMoveSpecifiedTenantDiscriminatorColumn() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.foo");
		XmlMultitenantHolder multitenantHolder = (XmlMultitenantHolder) getXmlEntityMappings().getEntities().get(0);
		multitenantHolder.setMultitenant(EclipseLinkOrmFactory.eINSTANCE.createXmlMultitenant());

		OrmEclipseLinkMultitenancy2_3 ormMultitenancy = ((OrmEclipseLinkEntity) ormPersistentType.getMapping()).getMultitenancy();
		XmlMultitenant multitenantResource = multitenantHolder.getMultitenant();

		ormMultitenancy.addSpecifiedTenantDiscriminatorColumn(0).setSpecifiedName("FOO");
		ormMultitenancy.addSpecifiedTenantDiscriminatorColumn(1).setSpecifiedName("BAR");
		ormMultitenancy.addSpecifiedTenantDiscriminatorColumn(2).setSpecifiedName("BAZ");

		assertEquals(3, multitenantResource.getTenantDiscriminatorColumns().size());


		ormMultitenancy.moveSpecifiedTenantDiscriminatorColumn(2, 0);
		ListIterator<OrmTenantDiscriminatorColumn2_3> tenantDiscriminatorColumns = ormMultitenancy.getSpecifiedTenantDiscriminatorColumns().iterator();
		assertEquals("BAR", tenantDiscriminatorColumns.next().getName());
		assertEquals("BAZ", tenantDiscriminatorColumns.next().getName());
		assertEquals("FOO", tenantDiscriminatorColumns.next().getName());

		assertEquals("BAR", multitenantResource.getTenantDiscriminatorColumns().get(0).getName());
		assertEquals("BAZ", multitenantResource.getTenantDiscriminatorColumns().get(1).getName());
		assertEquals("FOO", multitenantResource.getTenantDiscriminatorColumns().get(2).getName());


		ormMultitenancy.moveSpecifiedTenantDiscriminatorColumn(0, 1);
		tenantDiscriminatorColumns = ormMultitenancy.getSpecifiedTenantDiscriminatorColumns().iterator();
		assertEquals("BAZ", tenantDiscriminatorColumns.next().getName());
		assertEquals("BAR", tenantDiscriminatorColumns.next().getName());
		assertEquals("FOO", tenantDiscriminatorColumns.next().getName());

		assertEquals("BAZ", multitenantResource.getTenantDiscriminatorColumns().get(0).getName());
		assertEquals("BAR", multitenantResource.getTenantDiscriminatorColumns().get(1).getName());
		assertEquals("FOO", multitenantResource.getTenantDiscriminatorColumns().get(2).getName());
	}

	public void testUpdateTenantDiscriminatorColumns() throws Exception {
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.foo");
		XmlMultitenantHolder multitenantHolder = (XmlMultitenantHolder) getXmlEntityMappings().getEntities().get(0);
		multitenantHolder.setMultitenant(EclipseLinkOrmFactory.eINSTANCE.createXmlMultitenant());

		OrmEclipseLinkMultitenancy2_3 ormMultitenancy = ((OrmEclipseLinkEntity) ormPersistentType.getMapping()).getMultitenancy();
		XmlMultitenant multitenantResource = multitenantHolder.getMultitenant();

		multitenantResource.getTenantDiscriminatorColumns().add(EclipseLinkOrmFactory.eINSTANCE.createXmlTenantDiscriminatorColumn());
		multitenantResource.getTenantDiscriminatorColumns().add(EclipseLinkOrmFactory.eINSTANCE.createXmlTenantDiscriminatorColumn());
		multitenantResource.getTenantDiscriminatorColumns().add(EclipseLinkOrmFactory.eINSTANCE.createXmlTenantDiscriminatorColumn());

		multitenantResource.getTenantDiscriminatorColumns().get(0).setName("FOO");
		multitenantResource.getTenantDiscriminatorColumns().get(1).setName("BAR");
		multitenantResource.getTenantDiscriminatorColumns().get(2).setName("BAZ");

		ListIterator<OrmTenantDiscriminatorColumn2_3> tenantDiscriminatorColumns = ormMultitenancy.getSpecifiedTenantDiscriminatorColumns().iterator();
		assertEquals("FOO", tenantDiscriminatorColumns.next().getName());
		assertEquals("BAR", tenantDiscriminatorColumns.next().getName());
		assertEquals("BAZ", tenantDiscriminatorColumns.next().getName());
		assertFalse(tenantDiscriminatorColumns.hasNext());

		multitenantResource.getTenantDiscriminatorColumns().move(2, 0);
		tenantDiscriminatorColumns = ormMultitenancy.getSpecifiedTenantDiscriminatorColumns().iterator();
		assertEquals("BAR", tenantDiscriminatorColumns.next().getName());
		assertEquals("BAZ", tenantDiscriminatorColumns.next().getName());
		assertEquals("FOO", tenantDiscriminatorColumns.next().getName());
		assertFalse(tenantDiscriminatorColumns.hasNext());

		multitenantResource.getTenantDiscriminatorColumns().move(0, 1);
		tenantDiscriminatorColumns = ormMultitenancy.getSpecifiedTenantDiscriminatorColumns().iterator();
		assertEquals("BAZ", tenantDiscriminatorColumns.next().getName());
		assertEquals("BAR", tenantDiscriminatorColumns.next().getName());
		assertEquals("FOO", tenantDiscriminatorColumns.next().getName());
		assertFalse(tenantDiscriminatorColumns.hasNext());

		multitenantResource.getTenantDiscriminatorColumns().remove(1);
		tenantDiscriminatorColumns = ormMultitenancy.getSpecifiedTenantDiscriminatorColumns().iterator();
		assertEquals("BAZ", tenantDiscriminatorColumns.next().getName());
		assertEquals("FOO", tenantDiscriminatorColumns.next().getName());
		assertFalse(tenantDiscriminatorColumns.hasNext());

		multitenantResource.getTenantDiscriminatorColumns().remove(1);
		tenantDiscriminatorColumns = ormMultitenancy.getSpecifiedTenantDiscriminatorColumns().iterator();
		assertEquals("BAZ", tenantDiscriminatorColumns.next().getName());
		assertFalse(tenantDiscriminatorColumns.hasNext());

		multitenantResource.getTenantDiscriminatorColumns().remove(0);
		assertFalse(ormMultitenancy.getSpecifiedTenantDiscriminatorColumns().iterator().hasNext());
	}

	//MappedSuperclass specifies multitenancy, all subclass entities are multitenant by default.
	public void testTenantDiscriminatorColumnsWithMappedSuperclass() throws Exception {
		createTestMultitenantMappedSuperclass();
		createTestSubType();
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
		OrmPersistentType ormPersistentType2 = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, PACKAGE_NAME + ".AnnotationTestTypeChild");

		OrmEclipseLinkMultitenancy2_3 multitenancy = ((OrmEclipseLinkEntity) ormPersistentType2.getMapping()).getMultitenancy();
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("MS_TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());

		//if the entity specifies multitenant, then it does not get the tenant discriminator columns from the mapped superclass
		multitenancy.setSpecifiedType(EclipseLinkMultitenantType2_3.SINGLE_TABLE);
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());


		multitenancy.setSpecifiedMultitenant(false);
		getEntityMappings().getPersistenceUnitMetadata().setXmlMappingMetadataComplete(true);
		assertFalse(multitenancy.isMultitenant());
		assertEquals(0, multitenancy.getTenantDiscriminatorColumnsSize());

		OrmEclipseLinkMultitenancy2_3 mappedSuperclassMultitenancy = ((OrmEclipseLinkMappedSuperclass) ormPersistentType.getMapping()).getMultitenancy();
		mappedSuperclassMultitenancy.setSpecifiedMultitenant(true);
		mappedSuperclassMultitenancy.addSpecifiedTenantDiscriminatorColumn().setSpecifiedName("MS_TENANT_ID");
	
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("MS_TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());

		multitenancy.setSpecifiedType(EclipseLinkMultitenantType2_3.SINGLE_TABLE);
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());
	}

	//Root entity specifies multitenancy and SINGLE_TABLE inheritance, all subclass entities are multitenant by default.
	public void testTenantDiscriminatorColumnsWithInheritance() throws Exception {
		createTestMultitenantRootEntity();
		createTestSubType();

		getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, PACKAGE_NAME + ".AnnotationTestTypeChild");

		OrmEclipseLinkMultitenancy2_3 multitenancy = ((OrmEclipseLinkEntity) ormPersistentType.getMapping()).getMultitenancy();
		assertTrue(multitenancy.isMultitenant()); //multitenant by default from root entity
		assertFalse(multitenancy.isSpecifiedMultitenant());
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("ROOT_ENTITY_TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());

		ormPersistentType.getMapping().getRootEntity().setSpecifiedInheritanceStrategy(InheritanceType.JOINED);
		assertTrue(multitenancy.isMultitenant()); //multitenant by default from root entity
		assertFalse(multitenancy.isSpecifiedMultitenant());
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("ROOT_ENTITY_TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());

		ormPersistentType.getMapping().getRootEntity().setSpecifiedInheritanceStrategy(InheritanceType.TABLE_PER_CLASS);
		assertFalse(multitenancy.isMultitenant()); //not multitenant since inheritance strategy is table per class
		assertFalse(multitenancy.isSpecifiedMultitenant());
		assertEquals(0, multitenancy.getTenantDiscriminatorColumnsSize());

		EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = (EclipseLinkPersistenceUnitDefaults) getMappingFile().getRoot().getPersistenceUnitMetadata().getPersistenceUnitDefaults();
		persistenceUnitDefaults.addTenantDiscriminatorColumn().setSpecifiedName("PU_TENANT_ID");
		assertFalse(multitenancy.isMultitenant()); //not multitenant since inheritance strategy is table per class
		assertFalse(multitenancy.isSpecifiedMultitenant());
		assertEquals(0, multitenancy.getTenantDiscriminatorColumnsSize());

		//get the default tenant discriminator column from the persistence unit defaults instead of the root entity since inheritance strategy is table per class
		multitenancy.setSpecifiedMultitenant(true);
		assertTrue(multitenancy.isSpecifiedMultitenant());
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("PU_TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());		

		multitenancy.addSpecifiedTenantDiscriminatorColumn().setSpecifiedName("CHILD_TENANT_ID");
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("CHILD_TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());		

		ormPersistentType.getMapping().getRootEntity().setSpecifiedInheritanceStrategy(InheritanceType.JOINED);
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("CHILD_TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());		
	}

	public void testTenantDiscriminatorColumnsWithPersistenceUnitDefaults() throws Exception {
		createTestEntity();
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);

		EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = (EclipseLinkPersistenceUnitDefaults) getMappingFile().getRoot().getPersistenceUnitMetadata().getPersistenceUnitDefaults();
		persistenceUnitDefaults.addTenantDiscriminatorColumn().setSpecifiedName("PU_TENANT_ID");

		OrmEclipseLinkMultitenancy2_3 multitenancy = ((OrmEclipseLinkEntity) ormPersistentType.getMapping()).getMultitenancy();
		assertFalse(multitenancy.isMultitenant());
		assertEquals(0, multitenancy.getTenantDiscriminatorColumnsSize());

		multitenancy.setSpecifiedType(EclipseLinkMultitenantType2_3.SINGLE_TABLE);
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("PU_TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());

		//if there are specified tenant discriminator columns then there should not be any default ones
		multitenancy.addSpecifiedTenantDiscriminatorColumn().setSpecifiedName("ENTITY_TENANT_ID");
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals(0, multitenancy.getDefaultTenantDiscriminatorColumnsSize());
		assertEquals("ENTITY_TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());

		//if entity is not SINGLE_TABLE multitenant than there are no default tenant discriminator columns
		multitenancy.setSpecifiedType(EclipseLinkMultitenantType2_3.TABLE_PER_TENANT);
		assertEquals(0, multitenancy.getTenantDiscriminatorColumnsSize());

		//if entity is not SINGLE_TABLE multitenant than there are no default tenant discriminator columns
		multitenancy.setSpecifiedMultitenant(false);
		assertEquals(0, multitenancy.getTenantDiscriminatorColumnsSize());
	}

	public void testTenantDiscriminatorColumnsWithEntityMappingsDefaults() throws Exception {
		createTestEntity();
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);

		EclipseLinkEntityMappings entityMappings = (EclipseLinkEntityMappings) getMappingFile().getRoot();
		entityMappings.addSpecifiedTenantDiscriminatorColumn().setSpecifiedName("EM_TENANT_ID");

		OrmEclipseLinkMultitenancy2_3 multitenancy = ((OrmEclipseLinkEntity) ormPersistentType.getMapping()).getMultitenancy();
		assertFalse(multitenancy.isMultitenant());
		assertEquals(0, multitenancy.getTenantDiscriminatorColumnsSize());

		multitenancy.setSpecifiedType(EclipseLinkMultitenantType2_3.SINGLE_TABLE);
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("EM_TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());

		//if entity is not SINGLE_TABLE multitenant than there are no default tenant discriminator columns
		multitenancy.setSpecifiedType(EclipseLinkMultitenantType2_3.TABLE_PER_TENANT);
		assertEquals(0, multitenancy.getTenantDiscriminatorColumnsSize());

		//if entity is not SINGLE_TABLE multitenant than there are no default tenant discriminator columns
		multitenancy.setSpecifiedMultitenant(false);
		assertEquals(0, multitenancy.getTenantDiscriminatorColumnsSize());


		EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = (EclipseLinkPersistenceUnitDefaults) getMappingFile().getRoot().getPersistenceUnitMetadata().getPersistenceUnitDefaults();
		persistenceUnitDefaults.addTenantDiscriminatorColumn().setSpecifiedName("PU_TENANT_ID");

		multitenancy.setSpecifiedType(EclipseLinkMultitenantType2_3.SINGLE_TABLE);
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("EM_TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());
	}

	public void testTenantDiscriminatorColumnsWithJavaMultitenant() throws Exception {
		createTestEntity();
		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
		((EclipseLinkEntity) ormPersistentType.getJavaPersistentType().getMapping()).getMultitenancy().setSpecifiedMultitenant(true);
				
		OrmEclipseLinkMultitenancy2_3 multitenancy = ((OrmEclipseLinkEntity) ormPersistentType.getMapping()).getMultitenancy();
		assertTrue(multitenancy.isMultitenant()); //isMultitenant is true because the java entity specifies @Multitenant
		assertFalse(multitenancy.isSpecifiedMultitenant());
		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());

		EclipseLinkEntityMappings entityMappings = (EclipseLinkEntityMappings) getMappingFile().getRoot();
		entityMappings.addSpecifiedTenantDiscriminatorColumn().setSpecifiedName("EM_TENANT_ID");

		assertEquals(1, multitenancy.getTenantDiscriminatorColumnsSize());
		assertEquals("EM_TENANT_ID", multitenancy.getTenantDiscriminatorColumns().iterator().next().getName());


		OrmPersistenceUnitMetadata persistenceUnitMetadata = (OrmPersistenceUnitMetadata) getMappingFile().getRoot().getPersistenceUnitMetadata();
		persistenceUnitMetadata.setXmlMappingMetadataComplete(true);
		assertFalse(multitenancy.isMultitenant());
		assertEquals(0, multitenancy.getTenantDiscriminatorColumnsSize());
	}
}