PreferencesControllerTest

/**
 * Copyright 2011-2013 The Kuali Foundation Licensed under the
 * Educational Community 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.osedu.org/licenses/ECL-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.kuali.mobility.push.controller;

import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.when;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.TimeZone;

import net.sf.json.JSONSerializer;

import org.apache.log4j.Logger;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.kuali.mobility.push.controllers.PreferencesController;
import org.kuali.mobility.push.entity.Preference;
import org.kuali.mobility.push.entity.Sender;
import org.kuali.mobility.push.service.PreferenceService;
import org.kuali.mobility.push.service.SenderService;
import org.kuali.mobility.security.authn.util.AuthenticationConstants;
import org.kuali.mobility.security.user.api.User;
import org.kuali.mobility.security.user.api.UserDao;
import org.kuali.mobility.security.user.entity.UserImpl;
import org.mockito.Mock;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.mock.web.MockHttpSession;
import org.springframework.mock.web.MockServletContext;
import org.springframework.ui.ExtendedModelMap;
import org.springframework.ui.Model;

/**
 * @author Kuali Mobility Team (mobility.collab@kuali.org)
 */
/**
 * @author mtwagner
 *
 */
@RunWith(org.mockito.runners.MockitoJUnitRunner.class)
public class PreferencesControllerTest {

	/** A reference to a logger */
	private static final Logger LOG = Logger.getLogger(PreferencesControllerTest.class);

	private static MockServletContext servletContext;
	private PreferencesController controller;
	@Mock
    private PreferenceService prefService;

	@Mock
    private SenderService senderService;

	private MockHttpServletRequest request;
	private MockHttpServletResponse response;
	private Model uiModel;

	@Mock
	private Preference preference;
	@Mock
	private User user;
	@Mock
	private UserDao userDao;


	@BeforeClass
	public static void setUpClass() throws Exception {
		servletContext = new MockServletContext();
	}

	@Before
	public void preTest() {
		this.setController(new PreferencesController());
		this.getController().setPreferenceService(prefService);
		this.getController().setSenderService(senderService);
		this.setRequest(new MockHttpServletRequest(servletContext));
		this.setResponse(new MockHttpServletResponse());
		this.setUiModel(new ExtendedModelMap());
		this.getRequest().setSession(new MockHttpSession(servletContext));
		this.getRequest().getSession().setAttribute(AuthenticationConstants.KME_USER_KEY, getUser());
	}

	@Test
	public void testPing() {
		ResponseEntity <String> responseEntity = getController().ping();
		ResponseEntity<String> expectedEntity = new ResponseEntity<String>(HttpStatus.OK);
		assertTrue("Expected response of OK was not found.",(expectedEntity.getStatusCode()).equals(responseEntity.getStatusCode()));
	}

	@Test
	public void testLogin() {
		String viewName = getController().login(getRequest(), getUiModel(), "key");
		List<Sender> senders = new ArrayList<Sender>();
		when(getSenderService().findAllSenders()).thenReturn(senders);
		assertTrue("View name does not match expected value.","redirect:/pushprefs".equals(viewName));
	}

	@Test
	public void testGetPreferencesWithNullUsername(){
		String expected = "{\"preferences\":[]}";
		User user = new UserImpl();
		List<Preference> preferences = new ArrayList<Preference>();
		when(getPrefService().findPreferencesByUsername("")).thenReturn(preferences);

		String output = getController().getPreferences(getUiModel(), getRequest(), "");
		LOG.info("expected: [" + expected + "]");
		LOG.info("output:   [" + output + "]");
		assertTrue("Output does not match expected value.", expected.equals(output));
	}

	@Test
	public void testGetPreferencesWithUsername(){
		Timestamp ts = new Timestamp(123456789L);
		String timestampJson = new JSONSerializer().toJSON(ts).toString();
		String expected = "{\"preferences\":[{\"enabled\":false,\"id\":1,\"postedTimestamp\":"+timestampJson+",\"pushSenderID\":1,\"senderBlocked\":true,\"username\":\"userA\",\"versionNumber\":0}]}";
		Preference preference = new Preference();
		preference.setId(1L);
		preference.setPushSenderID(1L);
		preference.setUsername("userA");

		preference.setPostedTimestamp(ts);
		List<Preference> preferences = new ArrayList<Preference>();
		preferences.add(preference);

		when(getPrefService().findPreferencesByUsername("userA")).thenReturn(preferences);
		String output = getController().getPreferences(getUiModel(), getRequest(), "userA");
		LOG.info("expected: [" + expected + "]");
		LOG.info("output:   [" + output + "]");

		assertTrue("Output does not match expected value.", expected.equals(output));
	}

	@Test
	public void testRegisterNewPreferences() {
		String data = "{\"enabled\":true,\"username\":\"bob\",\"senderId\":1}";
		when(getPrefService().findPreference(any(String.class), any(Sender.class))).thenReturn(null);
		ResponseEntity<String> responseEntity = getController().register(data);
		ResponseEntity<String> expectedEntity = new ResponseEntity<String>(HttpStatus.OK);
		assertTrue("Expected response of OK was not found.", (expectedEntity.getStatusCode()).equals(responseEntity.getStatusCode()));
	}

	@Test
	public void testRegisterPreferencesWithInvalidData() {
		String data = "{\"enabled:true,\"username\":\"bob\",\"senderId\":1}";
		when(getPrefService().findPreference(any(String.class), any(Sender.class))).thenReturn(null);
		ResponseEntity<String> responseEntity = getController().register(data);
		ResponseEntity<String> expectedEntity = new ResponseEntity<String>(HttpStatus.BAD_REQUEST);
		assertTrue("Expected response of BAD_REQUEST was not found.", (expectedEntity.getStatusCode()).equals(responseEntity.getStatusCode()));
	}

	@Test
	public void testRegisterPreferencesWithNullData() {
		when(getPrefService().findPreference(any(String.class), any(Sender.class))).thenReturn(null);
		ResponseEntity<String> responseEntity = getController().register(null);
		ResponseEntity<String> expectedEntity = new ResponseEntity<String>(HttpStatus.NO_CONTENT);
		assertTrue("Expected response of NO_CONTENT was not found.", (expectedEntity.getStatusCode()).equals(responseEntity.getStatusCode()));
	}

	/**
	 * @return the servletContext
	 */
	public static MockServletContext getServletContext() {
		return servletContext;
	}
	/**
	 * @param servletContext the servletContext to set
	 */
	public static void setServletContext(MockServletContext servletContext) {
		PreferencesControllerTest.servletContext = servletContext;
	}
	/**
	 * @return the controller
	 */
	public PreferencesController getController() {
		return controller;
	}
	/**
	 * @param controller the controller to set
	 */
	public void setController(PreferencesController controller) {
		this.controller = controller;
	}


	/**
	 * @return the prefService
	 */
	public PreferenceService getPrefService() {
		return prefService;
	}

	/**
	 * @param prefService the prefService to set
	 */
	public void setPrefService(PreferenceService prefService) {
		this.prefService = prefService;
	}

	/**
	 * @return the senderService
	 */
	public SenderService getSenderService() {
		return senderService;
	}

	/**
	 * @param senderService the senderService to set
	 */
	public void setSenderService(SenderService senderService) {
		this.senderService = senderService;
	}

	/**
	 * @return the request
	 */
	public MockHttpServletRequest getRequest() {
		return request;
	}
	/**
	 * @param request the request to set
	 */
	public void setRequest(MockHttpServletRequest request) {
		this.request = request;
	}
	/**
	 * @return the response
	 */
	public MockHttpServletResponse getResponse() {
		return response;
	}
	/**
	 * @param response the response to set
	 */
	public void setResponse(MockHttpServletResponse response) {
		this.response = response;
	}
	/**
	 * @return the uiModel
	 */
	public Model getUiModel() {
		return uiModel;
	}
	/**
	 * @param uiModel the uiModel to set
	 */
	public void setUiModel(Model uiModel) {
		this.uiModel = uiModel;
	}
	/**
	 * @return the preference
	 */
	public Preference getPreference() {
		return preference;
	}

	/**
	 * @param preference the preference to set
	 */
	public void setPreference(Preference preference) {
		this.preference = preference;
	}

	/**
	 * @return the user
	 */
	public User getUser() {
		return user;
	}
	/**
	 * @param user the user to set
	 */
	public void setUser(User user) {
		this.user = user;
	}
	/**
	 * @return the userDao
	 */
	public UserDao getUserDao() {
		return userDao;
	}
	/**
	 * @param userDao the userDao to set
	 */
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}


}