package org.jellyfish.implementation;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   
   import javax.naming.NameNotFoundException;
   import javax.naming.NamingEnumeration;
   import javax.naming.NamingException;
  import javax.naming.directory.Attributes;
  import javax.naming.directory.BasicAttributes;
  import javax.naming.directory.DirContext;
  import javax.naming.directory.SearchResult;
  
  import junit.framework.TestCase;
  import mock.javax.naming.directory.DirContextMock;
  import mock
  	.org
  	.apache
  	.avalon
  	.framework
  	.service
  	.ServiceManagerMock
  	.ServiceManagerMock;
  
  import org.jellyfish.ConnectionManager;
  import org.jellyfish.ConnectionManagerMock;
  import org.jellyfish.MappingManager;
  import org.jellyfish.MappingManagerMock;
  import org.jellyfish.config.AttributeMapping;
  import org.jellyfish.config.ObjectMapping;
  import org.jellyfish.model.Person;
  
  public class DirectoryManagerDefaultTest extends TestCase {
  
  	private DirectoryManagerDefault directoryManager;
  	private ServiceManagerMock serviceManagerMock;
  	private ConnectionManagerMock connectionManagerMock;
  	private MappingManagerMock mappingManagerMock;
  
  	private String PERSON = "person";
  	private Person person;
  
  	public DirectoryManagerDefaultTest(String arg0) {
  		super(arg0);
  	}
  
  	protected void setUp() throws Exception {
  		connectionManagerMock = new ConnectionManagerMock();
  		connectionManagerMock.getContextReturn = new DirContextMock();
  		serviceManagerMock = new ServiceManagerMock();
  		serviceManagerMock.lookupMap.put(
  			ConnectionManager.ROLE,
  			connectionManagerMock);
  		mappingManagerMock = createMappingManagerMock();
  		serviceManagerMock.lookupMap.put(
  			MappingManager.ROLE,
  			mappingManagerMock);
  		directoryManager = new DirectoryManagerDefault();
  		directoryManager.service(serviceManagerMock);
  		person = createPerson();
  	}
  
  	private MappingManagerMock createMappingManagerMock() {
  		MappingManagerMock mock = new MappingManagerMock();
  		mock.mapToAttributesReturn = createAttributes();
  		mock.getObjectDnReturn = "cn=joe,ou=people,dc=jellyfish,dc=org";
  		mock.getObjectMappingReturn = createObjectMapping();
  		return mock;
  	}
  
  	private ObjectMapping createObjectMapping() {
  		ObjectMapping objectMapping = new ObjectMapping();
  		objectMapping.setJavaName(Person.class.getName());
  		objectMapping.setLdapName(PERSON);
  		objectMapping.setDn("cn=${firstName},ou=people");
  		objectMapping.setAttributeMappings(new ArrayList());
  		objectMapping.getAttributeMappings().add(
  			new AttributeMapping("firstName", "cn"));
  		objectMapping.getAttributeMappings().add(
  			new AttributeMapping("lastName", "sn"));
  		return objectMapping;
  	}
  
  	private Person createPerson() {
  		return new Person("Joe", "Smith");
  	}
  
  	private Attributes createAttributes() {
  		Attributes attributes = new BasicAttributes();
  		attributes.put(MappingManager.OBJECTCLASS, "person");
  		attributes.put("cn", "Joe");
  		attributes.put("sn", "Smith");
  		return attributes;
  	}
  
  	private NamingEnumeration createNamingEnumeration() {
  		final Collection results = new ArrayList();
  		SearchResult searchResultOne =
 			new SearchResult(
 				"cn=joe,ou=people,dc=jellyfish,dc=org",
 				new Person(),
 				createAttributes());
 		results.add(searchResultOne);
 		NamingEnumeration namingEnumeration = new NamingEnumeration() {
 			private Iterator iterator = results.iterator();
 			public void close() throws NamingException {
 				throw new UnsupportedOperationException("Implement me.");
 			}
 
 			public boolean hasMore() throws NamingException {
 				return hasMoreElements();
 			}
 
 			public Object next() throws NamingException {
 				return nextElement();
 			}
 
 			public boolean hasMoreElements() {
 				return iterator.hasNext();
 			}
 
 			public Object nextElement() {
 				return iterator.next();
 
 			}
 		};
 		return namingEnumeration;
 	}
 
 	public void testStore() {
 		directoryManager.store(person);
 		assertTrue(mappingManagerMock.mapToAttributesCalled);
 		assertTrue(mappingManagerMock.getObjectDnCalled);
 		assertTrue(connectionManagerMock.getContextCalled);
 		assertTrue(
 			connectionManagerMock.getContextReturn.modifyAttributesCalled);
 		assertEquals(
 			mappingManagerMock.getObjectDnReturn,
 			connectionManagerMock.getContextReturn.modifyAttributesName);
 		assertEquals(
 			DirContext.REPLACE_ATTRIBUTE,
 			connectionManagerMock.getContextReturn.modifyAttributesModOp);
 		assertEquals(
 			mappingManagerMock.mapToAttributesReturn,
 			connectionManagerMock.getContextReturn.modifyAttributesAttributes);
 	}
 
 	public void testStoreNameNotFound() throws NamingException {
 		connectionManagerMock
 			.getContextReturn
 			.modifyAttributesNameNotFoundException =
 			new NameNotFoundException();
 		directoryManager.store(person);
 		assertTrue(
 			connectionManagerMock.getContextReturn.createSubcontextCalled);
 		assertEquals(
 			PERSON,
 			connectionManagerMock
 				.getContextReturn
 				.createSubcontextAttributes
 				.get("objectclass")
 				.get());
 	}
 
 	public void testLookup() {
 		connectionManagerMock.getContextReturn.getAttributesReturn =
 			createAttributes();
 		mappingManagerMock.mapFromAttributesReturn = person;
 
 		Person personReturned = (Person) directoryManager.lookup(person);
 
 		assertTrue(mappingManagerMock.getObjectDnCalled);
 		assertTrue(mappingManagerMock.mapFromAttributesCalled);
 		assertTrue(connectionManagerMock.getContextCalled);
 		assertTrue(connectionManagerMock.getContextReturn.getAttributesCalled);
 		assertEquals(
 			connectionManagerMock.getContextReturn.getAttributesReturn,
 			mappingManagerMock.mapFromAttributesAttributes);
 		assertEquals(person.getFirstName(), personReturned.getFirstName());
 	}
 
 	public void testDelete() {
 		directoryManager.delete((Object) person);
 		assertTrue(mappingManagerMock.getObjectDnCalled);
 		assertTrue(
 			connectionManagerMock.getContextReturn.destroySubcontextCalled);
 	}
 
 	public void testSearch() {
 		connectionManagerMock.getContextReturn.searchReturn =
 			createNamingEnumeration();
 		mappingManagerMock.mapFromAttributesReturn = createPerson();
 		Collection matches = directoryManager.search((Object) person);
 		assertTrue(mappingManagerMock.mapToAttributesCalled);
 		assertTrue(mappingManagerMock.getObjectDnCalled);
 		assertTrue(connectionManagerMock.getContextReturn.searchCalled);
 		assertEquals(
 			"ou=people,dc=jellyfish,dc=org",
 			connectionManagerMock.getContextReturn.searchName);
 		assertEquals(
 			mappingManagerMock.mapToAttributesReturn,
 			connectionManagerMock.getContextReturn.searchMatchingAttributes);
 		assertTrue(mappingManagerMock.mapFromAttributesCalled);
 	}
 }