/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.

 */

package client;

import java.io.IOException;

import java.lang.reflect.UndeclaredThrowableException;

import java.util.ArrayList;

import java.util.List;

import org.junit.Before;

import org.junit.Test;

import org.opensolaris.os.rad.ObjectException;

import org.opensolaris.os.rad.test.RadRequestMXBean;

import org.opensolaris.os.rad.api.pam.Block;

import org.opensolaris.os.rad.api.pam.BlockType;

import org.opensolaris.os.rad.api.pam.Message;

import org.opensolaris.os.rad.api.pam.MsgType;

import testutil.Desc;

import static org.junit.Assert.*;

public class PAMConvTest extends PAMTestBase {

    static final String USCE_CLASSNAME =

	"com.oracle.solaris.afunix.UnixSocketClosedException";

    static final int CONN_TO = 3;

    @Before

    public void setUp() throws Exception {

	assertTrue(isRadReady(false)); // unauth

    }

    @Test

    @Desc("Connecting to the container without authentication correctly" +

	  " reports that you aren't authenticated.")

    public void authUserUserNone() throws Exception {

	String serverUserName = bean_.getuser();

	assertNull(serverUserName);

    }

    @Test

    @Desc("Connecting to the container without authentication correcctly" +

	  " reports you have no roles availables.")

    public void authRolesNone() throws Exception {

	List<String>roles = bean_.getroles();

	assertNotNull(roles);

	assertEquals(0, roles.size());

    }

    @Test

    @Desc("Connecting to the container with authentication correctly" +

	  " resports the roles available to the authenticated user.")

    public void authRolesCorrect() throws Exception {

	String username = "radtest_hasroles";

	String prompt = "Password:";

	String password = "simplepass";

	String myroles[] =

	    new String[] {"radtest_rolepass", "radtest_rolenopass"};

	Block block = bean_.login(locale_, username);

	assertNotNull(block);

	assertEquals(BlockType.conv, block.getType());

	List<Message>messages = block.getMessages();

	assertNotNull(messages);

	assertEquals(1, messages.size());

	assertEquals(prompt, messages.get(0).getMessage());

	List<char[]>resp = new ArrayList<char[]>();

	resp.add(password.toCharArray());

	block = bean_.submit(resp);

	assertNotNull(block);

	assertEquals(BlockType.success, block.getType());

	List<String>roles = bean_.getroles();

	assertNotNull(roles);

	assertEquals(myroles.length, roles.size());

	// the rolenames returned are the expected ones.

	assertTrue(roles.contains(myroles[0]) && roles.contains(myroles[1]));

    }

    @Test

    @Desc("Authentication as a bogus user failes immediately.")

    public void authLoginBogusUser() throws Exception {

	String username = "bogususer";

	Block block = bean_.login(locale_, username);

	assertNotNull(block);

	assertEquals(BlockType.error, block.getType());

	assertNull(bean_.getuser());

    }

    @Test

    @Desc("Authentication as user that doesn't have password completes" +

	  " successfully.")

    public void authLoginNoPassword() throws Exception {

	String username = "radtest_nopass";

	Block block = bean_.login(locale_, username);

	assertNotNull(block);

	assertEquals(BlockType.success, block.getType());

	assertEquals(username, bean_.getuser());

    }

    @Test

    @Desc("Authentication as user that has password completes successfully")

    public void authLoginPassword() throws Exception {

	String username = "radtest_simple";

	String prompt = "Password:";

	String password = "simplepass";

	Block block = bean_.login(locale_, username);

	assertNotNull(block);

	assertEquals(BlockType.conv, block.getType());

	List<Message> messages = block.getMessages();

	assertNotNull(messages);

	assertEquals(1, messages.size());

	assertEquals(prompt, messages.get(0).getMessage());

	List<char[]>resp = new ArrayList<char[]>();

	resp.add(password.toCharArray());

	block = bean_.submit(resp);

	assertNotNull(block);

	assertEquals(BlockType.success, block.getType());

	assertEquals(username, bean_.getuser());

    }

    @Test

    @Desc("Authntication as user that has password fails when bad password" +

	  " is provided")

    public void authLoginPasswordFail() throws Exception {

	String username = "radtest_simple";

	String prompt = "Password:";

	String password = "badpassword";

	Block block = bean_.login(locale_, username);

	assertNotNull(block);

	assertEquals(BlockType.conv, block.getType());

	List<Message> messages = block.getMessages();

	assertNotNull(messages);

	assertEquals(1, messages.size());

	assertEquals(prompt, messages.get(0).getMessage());

	List<char[]>resp = new ArrayList<char[]>();

	resp.add(password.toCharArray());

	block = bean_.submit(resp);

	assertNotNull(block);

	assertEquals(BlockType.error, block.getType());

	assertNull(bean_.getuser());

    }

    @Test

    @Desc("Authentication as user that has password completes successfully," +

	  " with trailing message")

    public void authLoginPasswordTrailing() throws Exception {

	String username = "radtest_trailing";

	String prompt = "Password:";

	String password = "simplepass";

	String trailingPrompt = "Thank you!";

	Block block = bean_.login(locale_, username);

	assertNotNull(block);

	assertEquals(BlockType.conv, block.getType());

	List<Message> messages = block.getMessages();

	assertNotNull(messages);

	assertEquals(1, messages.size());

	assertEquals(prompt, messages.get(0).getMessage());

	List<char[]>resp = new ArrayList<char[]>();

	resp.add(password.toCharArray());

	block = bean_.submit(resp);

	assertNotNull(block);

	assertEquals(BlockType.conv, block.getType());

	messages = block.getMessages();

	assertNotNull(messages);

	assertEquals(1, messages.size());

	assertEquals(MsgType.text_info, messages.get(0).getStyle());

	assertEquals(trailingPrompt, messages.get(0).getMessage());

	resp = new ArrayList<char []>();

	block = bean_.submit(resp);

	assertNotNull(block);

	assertEquals(BlockType.success, block.getType());

	assertEquals(username, bean_.getuser());

    }

    /**

     * authenticate a user using multiple prompts in serial.

     * @param aPass - password for the first prompt.

     * @param bPass - password for the second prompt.

     * @return boolean - true if successully authenticated, otherwise false.

     */

    private boolean authLoginMultipleSerial(String aPass, String bPass)

	throws Exception {

	String username = "radtest_serial";

	String promptA = "Password A:";

	String promptB = "Password B:";

	Block block = bean_.login(locale_, username);

	assertNotNull(block);

	assertEquals(BlockType.conv, block.getType());

	List<Message> messages = block.getMessages();

	assertNotNull(messages);

	assertEquals(1, messages.size());

	assertEquals(promptA, messages.get(0).getMessage());

	List<char[]>resp = new ArrayList<char[]>();

	resp.add(aPass.toCharArray());

	block = bean_.submit(resp);

	assertNotNull(block);

	if (block.getType() != BlockType.conv)

	    return false;

	messages = block.getMessages();

	assertNotNull(messages);

	assertEquals(1, messages.size());

	assertEquals(promptB, messages.get(0).getMessage());

	resp = new ArrayList<char[]>();

	resp.add(bPass.toCharArray());

	block = bean_.submit(resp);

	assertNotNull(block);

	return (block.getType() == BlockType.success);

    }

    @Test

    @Desc("Authentication as user using mulitple prompts in serial completes" +

	  " successfully.")

    public void authLoginMultipleSerial() throws Exception {

	assertTrue(authLoginMultipleSerial("Apass", "Bpass"));

	assertEquals("radtest_serial", bean_.getuser());

    }

    @Test

    @Desc("Authentication as user using multiple prompts in serial fails" +

	  " when the first password is wrong")

    public void authLoginMutipleSerialA() throws Exception {

	assertFalse(authLoginMultipleSerial("ABadpass", "Bpass"));

	assertNull(bean_.getuser());

    }

    @Test

    @Desc("Authentication as user using multiple prompts in serial fails" +

	  " when the second password is wrong")

    public void authLoginMultipleSerialB() throws Exception {

	assertFalse(authLoginMultipleSerial("Apass", "BBadpass"));

	assertNull(bean_.getuser());

    }

    /**

     * authenticate a user using multiple prompts in parallel.

     * @param passowrd - a list a passwords to used as response.

     * @return boolean - true if successful, otherwise false.

     */

    private boolean authLoginMultipleParallel(List<char[]>passList)

	throws Exception {

	String username = "radtest_parallel";

	String [] prompts = new String[] {"Password A:", "Password B:"};

	Block block = bean_.login(locale_, username);

	assertNotNull(block);

	assertEquals(BlockType.conv, block.getType());

	List<Message>messages = block.getMessages();

	assertNotNull(messages);

	assertEquals(2, messages.size());

	assertEquals(prompts[0], messages.get(0).getMessage());

	assertEquals(prompts[1], messages.get(1).getMessage());

	block = bean_.submit(passList);

	assertNotNull(block);

	return (block.getType() == BlockType.success);

    }

    @Test

    @Desc("Authnetication as user using multiple prompts simultaneously" +

	  " completes successfully.")

    public void authLoginMultipleParallel() throws Exception {

	List<char[]>resp = new ArrayList<char[]>();

	resp.add("Apass".toCharArray());

	resp.add("Bpass".toCharArray());

	assertTrue(authLoginMultipleParallel(resp));

	assertEquals("radtest_parallel", bean_.getuser());

    }

    @Test

    @Desc("Autentication as user using multiple prompts simultaneously" +

	  " fails when passwords are wrong.")

    public void authLoginMultipleParallelFail() throws Exception {

	List<char[]>resp = new ArrayList<char[]>();

	resp.add("ABadPass".toCharArray());

	resp.add("BBadPass".toCharArray());

	assertFalse(authLoginMultipleParallel(resp));

	assertNull(bean_.getuser());

    }

    @Test

    @Desc("Authentication as user using multiple prompts simultaneously" +

	  " fails when only one password is provided.")

    public void authLoginMultipleParallelFailShort() throws Exception {

	List<char[]>resp = new ArrayList<char[]>();

	resp.add("Apass".toCharArray());

	boolean successful = false;

	try {

	    authLoginMultipleParallel(resp);

	} catch (ObjectException oe) {

	    // We expect an ObjectException to be thrown

	    successful = true;

	}

	assertNull(bean_.getuser());

	assertTrue(successful);

    }

    @Test

    @Desc("Authentication as user using multiple prompts simultaneously" +

	  " fails when too many passwords are provided.")

    public void authLoginMultipleParallelFailLong() throws Exception {

	List<char[]>resp = new ArrayList<char[]>();

	resp.add("Apass".toCharArray());

	resp.add("Bpass".toCharArray());

	resp.add("OneTooManyPass".toCharArray());

	boolean successful = false;

	try {

	    authLoginMultipleParallel(resp);

	} catch (ObjectException oe) {

	    // We expect an ObjectException to be thrown

	    successful = true;

	}

	assertNull(bean_.getuser());

	assertTrue(successful);

    }

    @Test

    @Desc("Authentication as expired user fails.")

    public void authLoginExpired() throws Exception {

	String username = "radtest_expired";

	String prompt = "Password:";

	String password = "simplepss";

	Block block = bean_.login(locale_, username);

	assertNotNull(block);

	assertEquals(BlockType.conv, block.getType());

	List<Message>messages = block.getMessages();

	assertNotNull(messages);

	assertEquals(1, messages.size());

	assertEquals(prompt, messages.get(0).getMessage());

	List<char[]>resp = new ArrayList<char[]>();

	resp.add(password.toCharArray());

	block = bean_.submit(resp);

	assertEquals(BlockType.error, block.getType());

	assertNull(bean_.getuser());

    }

    /**

     * common method used by the following three 'change password' tests.

     *

     * @param prompt [] - exptected prompts from the server.

     * @param response [] - proper responses to the prompts above.

     * @param BlockType [] - expected server responses to the responses above.

     */

    private void authLoginChangePasswordBase(String [] prompt,

        String [] response, BlockType [] blockType) throws Exception {

	String username = "radtest_stale";

	Block block = bean_.login(locale_, username);

	assertNotNull(block);

	assertEquals(BlockType.conv, block.getType());

	for (int i = 0; i < prompt.length; i++) {

	    List<Message>messages = block.getMessages();

	    assertNotNull(messages);

	    assertEquals(1, messages.size());

	    assertEquals(prompt[i], messages.get(0).getMessage());

	    List<char []>resp = new ArrayList<char []>();

	    if (response[i] != null) {

		resp.add(response[i].toCharArray());

	    }

	    block = bean_.submit(resp);

	    assertNotNull(block);

	    assertEquals(blockType[i], block.getType());

	}

    }

    @Test

    @Desc("Authentication as user with stale password is able to provide" +

	  " a new one.")

    public void authLoginChangePassword() throws Exception {

	String [] prompt = new String [] {"Password:",

					  "Your password has expired.",

					  "New Password:",

					  "New Password:"};

	String [] response = new String [] {"simplepass",

					    null,

					    "newpass",

					    "newpass"};

	BlockType [] blockType =  new BlockType [] {BlockType.conv,

						    BlockType.conv,

						    BlockType.conv,

						    BlockType.success};

	authLoginChangePasswordBase(prompt, response, blockType);

	assertEquals("radtest_stale", bean_.getuser());

    }

    @Test

    @Desc("Authentication as user with statel password is prompted for new" +

	  " one until successful.")

    public void authLoginChangePasswordRetry() throws Exception {

	String [] prompt =  new String [] {"Password:",

					   "Your password has expired.",

					   "New Password:",

					   "New Password:",

					   "New Password:"};

	String [] response = new String [] {"simplepass",

					    null,

					    "lamepass",

					    "newpass",

					    "newpass"};

	BlockType [] blockType = new BlockType [] {BlockType.conv,

						   BlockType.conv,

						   BlockType.conv,

						   BlockType.conv,

						   BlockType.success};

	authLoginChangePasswordBase(prompt, response, blockType);

	assertEquals("radtest_stale", bean_.getuser());

    }

    @Test

    @Desc("Authentication as user with stale password is prompted for new" +

	  " one but fails")

    public void authLoginChangePasswordFail() throws Exception {

	String [] prompt =  new String [] {"Password:",

					   "Your password has expired.",

					   "New Password:",

					   "New Password:",

					   "New Password:"};

	String [] response = new String [] {"simplepass",

					    null,

					    "firstbadpass",

					    "secondbadpass",

					    "thirdbadpass"};

	BlockType [] blockType = new BlockType [] {BlockType.conv,

						   BlockType.conv,

						   BlockType.conv,

						   BlockType.conv,

						   BlockType.error};

	authLoginChangePasswordBase(prompt, response, blockType);

	assertNull(bean_.getuser());

    }

    @Test

    @Desc("User is able to assume role without password")

    public void authAssumeNoPassword() throws Exception {

	// login as 'radtest_hasroles'

	authRolesCorrect();

	String rolename = "radtest_rolenopass";

	Block block = bean_.assume(locale_, rolename);

	assertNotNull(block);

	assertEquals(BlockType.success, block.getType());

	assertEquals(rolename, bean_.getuser());

    }

    @Test

    @Desc("User is able to assume a role with a password")

    public void authAssumePassword() throws Exception {

	String rolename = "radtest_rolepass";

	String prompt = "Password:";

	String rolepass = "rolepass";

	// login as 'radtest_hasroles'

	authRolesCorrect();

	Block block = bean_.assume(locale_, rolename);

	assertNotNull(block);

	assertEquals(BlockType.conv, block.getType());

	List<Message>messages = block.getMessages();

	assertEquals(1, messages.size());

	assertEquals(prompt, messages.get(0).getMessage());