/*
 * Copyright (C) 2014 Red Hat, Inc. and/or its affiliates.
 *
 * Licensed 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.jboss.errai.mocksafe.test;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;

import org.jboss.errai.enterprise.client.jaxrs.api.RestErrorCallback;
import org.jboss.errai.security.client.local.api.SecurityContext;
import org.jboss.errai.security.client.local.callback.DefaultBusSecurityErrorCallback;
import org.jboss.errai.security.client.local.callback.DefaultRestSecurityErrorCallback;
import org.jboss.errai.security.shared.exception.UnauthenticatedException;
import org.jboss.errai.security.shared.exception.UnauthorizedException;
import org.jboss.errai.ui.nav.client.local.api.LoginPage;
import org.jboss.errai.ui.nav.client.local.api.MissingPageRoleException;
import org.jboss.errai.ui.nav.client.local.api.SecurityError;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;

import com.google.gwt.http.client.Request;
import com.google.gwtmockito.GwtMockitoTestRunner;

@RunWith(GwtMockitoTestRunner.class)
public class DefaultErrorCallbackTest {

  @Mock
  private SecurityContext securityContext;

  @Mock(name = "wrapped")
  private RestErrorCallback wrapped;

  @InjectMocks
  private DefaultBusSecurityErrorCallback busErrorCallback;

  @InjectMocks
  private DefaultRestSecurityErrorCallback restErrorCallback;

  @Test
  public void testBusAuthenticationErrorNavigatesToLoginPage() throws Exception {
    busErrorCallback.handleError(new UnauthenticatedException());

    verify(securityContext).redirectToLoginPage();
  }

  @Test
  public void testBusAuthorizationErrorNavigatesToSecurityErrorPage() throws Exception {
    busErrorCallback.handleError(new UnauthorizedException());

    verify(securityContext).redirectToSecurityErrorPage();
  }

  @Test
  public void testBusOtherErrorIsIgnored() throws Exception {
    busErrorCallback.handleError(new Exception());

    verifyZeroInteractions(securityContext);
  }

  @Test
  public void testBusErrorCallbackThrowsErrorWhenNoLoginPageExists() throws Exception {
    final MissingPageRoleException toBeThrown = new MissingPageRoleException(LoginPage.class);
    doThrow(toBeThrown).when(securityContext).redirectToLoginPage();

    try {
      busErrorCallback.handleError(new UnauthenticatedException());
      fail("No exception was thrown.");
    }
    catch (RuntimeException ex) {
      // Precondition
      verify(securityContext).redirectToLoginPage();

      assertSame(toBeThrown, ex.getCause());
    }
  }

  @Test
  public void testBusErrorCallbackThrowsErrorWhenNoSecurityErrorPageExists() throws Exception {
    final MissingPageRoleException toBeThrown = new MissingPageRoleException(SecurityError.class);
    doThrow(toBeThrown).when(securityContext).redirectToSecurityErrorPage();

    try {
      busErrorCallback.handleError(new UnauthorizedException());
      fail("No exception was thrown.");
    }
    catch (RuntimeException ex) {
      // Precondition
      verify(securityContext).redirectToSecurityErrorPage();

      assertSame(toBeThrown, ex.getCause());
    }
  }

  @Test
  public void testRestAuthenticationErrorNavigatesToLoginPage() throws Exception {
    when(wrapped.error(any(Request.class), any(Throwable.class))).thenReturn(true);

    final boolean retVal = restErrorCallback.error(mock(Request.class), new UnauthenticatedException());

    assertFalse(retVal);
    verify(securityContext).redirectToLoginPage();
  }

  @Test
  public void testRestAuthorizationErrorNavigatesToSecurityErrorPage() throws Exception {
    when(wrapped.error(any(Request.class), any(Throwable.class))).thenReturn(true);

    final boolean retVal = restErrorCallback.error(mock(Request.class), new UnauthorizedException());

    assertFalse(retVal);
    verify(securityContext).redirectToSecurityErrorPage();
  }

  @Test
  public void testRestOtherErrorIsIgnored() throws Exception {
    when(wrapped.error(any(Request.class), any(Throwable.class))).thenReturn(true);

    final boolean retVal = restErrorCallback.error(mock(Request.class), new Throwable());

    assertTrue(retVal);
    verifyNoMoreInteractions(securityContext);
  }

  @Test
  public void testRestErrorCallbackThrowsErrorWhenNoSecurityErrorPageExists() throws Exception {
    final MissingPageRoleException toBeThrown = new MissingPageRoleException(SecurityError.class);

    doThrow(toBeThrown).when(securityContext).redirectToSecurityErrorPage();
    when(wrapped.error(any(Request.class), any(Throwable.class))).thenReturn(true);

    try {
      restErrorCallback.error(mock(Request.class), new UnauthorizedException());
      fail("No exception was thrown.");
    }
    catch (RuntimeException ex) {
      // Precondition
      verify(securityContext).redirectToSecurityErrorPage();

      assertSame(toBeThrown, ex.getCause());
    }
  }

  @Test
  public void testRestErrorCallbackThrowsErrorWhenNoLoginPageExists() throws Exception {
    final MissingPageRoleException toBeThrown = new MissingPageRoleException(LoginPage.class);

    doThrow(toBeThrown).when(securityContext).redirectToLoginPage();
    when(wrapped.error(any(Request.class), any(Throwable.class))).thenReturn(true);

    try {
      restErrorCallback.error(mock(Request.class), new UnauthenticatedException());
      fail("No exception was thrown.");
    }
    catch (RuntimeException ex) {
      // Precondition
      verify(securityContext).redirectToLoginPage();

      assertSame(toBeThrown, ex.getCause());
    }
  }

}