SchedulerResourceTest.java

/*!
 * This program is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License, version 2.1 as published by the Free Software
 * Foundation.
 *
 * You should have received a copy of the GNU Lesser General Public License along with this
 * program; if not, you can obtain a copy at http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
 * or from the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Lesser General Public License for more details.
 *
 * Copyright (c) 2002-2013 Pentaho Corporation..  All rights reserved.
 */
package org.pentaho.platform.web.http.api.resources;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.pentaho.platform.api.repository2.unified.UnifiedRepositoryException;
import org.pentaho.platform.api.scheduler2.IJobTrigger;
import org.pentaho.platform.api.scheduler2.Job;
import org.pentaho.platform.api.scheduler2.SchedulerException;
import org.pentaho.platform.web.http.api.resources.proxies.BlockStatusProxy;
import org.pentaho.platform.web.http.api.resources.services.SchedulerService;

import javax.ws.rs.core.Response;

import java.io.IOException;
import java.util.List;

import static javax.ws.rs.core.Response.Status.FORBIDDEN;
import static javax.ws.rs.core.Response.Status.UNAUTHORIZED;
import static javax.ws.rs.core.Response.Status.OK;
import static javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR;
import static org.mockito.Mockito.*;
import static org.junit.Assert.*;

public class SchedulerResourceTest {

  SchedulerResource schedulerResource;

  @Before
  public void setUp() {
    schedulerResource = spy( new SchedulerResource() );
    schedulerResource.schedulerService = mock( SchedulerService.class );
  }

  @After
  public void tearDown() {
    schedulerResource = null;
  }

  @Test
  public void testCreateJob() throws Exception {
    JobScheduleRequest mockRequest = mock( JobScheduleRequest.class );

    Job mockJob = mock( Job.class );
    doReturn( mockJob ).when( schedulerResource.schedulerService ).createJob( mockRequest );

    String jobId = "jobId";
    doReturn( jobId ).when( mockJob ).getJobId();

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildPlainTextOkResponse( jobId );

    Response testResponse = schedulerResource.createJob( mockRequest );
    assertEquals( mockResponse, testResponse );

    verify( schedulerResource.schedulerService, times( 1 ) ).createJob( mockRequest );
    verify( mockJob, times( 1 ) ).getJobId();
    verify( schedulerResource, times( 1 ) ).buildPlainTextOkResponse( jobId );
  }

  @Test
  public void testCreateJobError() throws Exception {
    JobScheduleRequest mockRequest = mock( JobScheduleRequest.class );

    SchedulerException mockSchedulerException = mock( SchedulerException.class );

    Throwable mockSchedulerExceptionCause = mock( Throwable.class );
    doReturn( mockSchedulerExceptionCause ).when( mockSchedulerException ).getCause();

    String schedulerExceptionMessage = "schedulerExceptionMessage";
    doReturn( schedulerExceptionMessage ).when( mockSchedulerExceptionCause ).getMessage();

    Response mockSchedulerExceptionResponse = mock( Response.class );
    doReturn( mockSchedulerExceptionResponse ).when( schedulerResource )
      .buildServerErrorResponse( schedulerExceptionMessage );

    IOException mockIOException = mock( IOException.class );

    Throwable mockIOExceptionCause = mock( Throwable.class );
    doReturn( mockIOExceptionCause ).when( mockIOException ).getCause();

    String ioExceptionMessage = "ioExceptionMessage";
    doReturn( ioExceptionMessage ).when( mockIOExceptionCause ).getMessage();

    Response mockIOExceptionResponse = mock( Response.class );
    doReturn( mockIOExceptionResponse ).when( schedulerResource ).buildServerErrorResponse( ioExceptionMessage );

    Response mockUnauthorizedResponse = mock( Response.class );
    doReturn( mockUnauthorizedResponse ).when( schedulerResource ).buildStatusResponse( UNAUTHORIZED );

    Response mockForbiddenResponse = mock( Response.class );
    doReturn( mockForbiddenResponse ).when( schedulerResource ).buildStatusResponse( FORBIDDEN );

    // Test 1
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).createJob( mockRequest );

    Response testResponse = schedulerResource.createJob( mockRequest );
    assertEquals( mockSchedulerExceptionResponse, testResponse );

    // Test 2
    doThrow( mockIOException ).when( schedulerResource.schedulerService ).createJob( mockRequest );

    testResponse = schedulerResource.createJob( mockRequest );
    assertEquals( mockIOExceptionResponse, testResponse );

    // Test 3
    SecurityException mockSecurityException = mock( SecurityException.class );
    doThrow( mockSecurityException ).when( schedulerResource.schedulerService ).createJob( mockRequest );

    testResponse = schedulerResource.createJob( mockRequest );
    assertEquals( mockUnauthorizedResponse, testResponse );

    // Test 4
    IllegalAccessException mockIllegalAccessException = mock( IllegalAccessException.class );
    doThrow( mockIllegalAccessException ).when( schedulerResource.schedulerService ).createJob( mockRequest );

    testResponse = schedulerResource.createJob( mockRequest );
    assertEquals( mockForbiddenResponse, testResponse );

    verify( mockSchedulerException, times( 1 ) ).getCause();
    verify( mockSchedulerExceptionCause, times( 1 ) ).getMessage();
    verify( schedulerResource, times( 1 ) ).buildServerErrorResponse( schedulerExceptionMessage );
    verify( mockIOException, times( 1 ) ).getCause();
    verify( mockIOExceptionCause, times( 1 ) ).getMessage();
    verify( schedulerResource, times( 1 ) ).buildServerErrorResponse( ioExceptionMessage );
    verify( schedulerResource, times( 1 ) ).buildStatusResponse( UNAUTHORIZED );
    verify( schedulerResource, times( 1 ) ).buildStatusResponse( FORBIDDEN );
    verify( schedulerResource.schedulerService, times( 4 ) ).createJob( mockRequest );
  }

  @Test
  public void testTriggerNow() throws Exception {
    JobRequest mockJobRequest = mock( JobRequest.class );

    String jobId = "jobId";
    doReturn( jobId ).when( mockJobRequest ).getJobId();

    Job mockJob = mock( Job.class );
    doReturn( mockJob ).when( schedulerResource.schedulerService ).triggerNow( jobId );

    Job.JobState mockJobState = Job.JobState.BLOCKED;
    doReturn( mockJobState ).when( mockJob ).getState();

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildPlainTextOkResponse( mockJobState.name() );

    Response testResponse = schedulerResource.triggerNow( mockJobRequest );
    assertEquals( mockResponse, testResponse );

    verify( mockJobRequest, times( 1 ) ).getJobId();
    verify( schedulerResource.schedulerService, times( 1 ) ).triggerNow( jobId );
    verify( mockJob, times( 1 ) ).getState();
    verify( schedulerResource, times( 1 ) ).buildPlainTextOkResponse( mockJobState.name() );
  }

  @Test
  public void testTriggerNowError() throws Exception {
    JobRequest mockJobRequest = mock( JobRequest.class );

    String jobId = "jobId";
    doReturn( jobId ).when( mockJobRequest ).getJobId();

    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).triggerNow( jobId );

    try {
      schedulerResource.triggerNow( mockJobRequest );
      fail();
    } catch ( RuntimeException e ) {
      // correct
    }

    verify( mockJobRequest, times( 1 ) ).getJobId();
    verify( schedulerResource.schedulerService, times( 1 ) ).triggerNow( jobId );
  }

  @Test
  public void testGetContentCleanerJob() throws Exception {
    Job mockJob = mock( Job.class );
    doReturn( mockJob ).when( schedulerResource.schedulerService ).getContentCleanerJob();

    Job testJob = schedulerResource.getContentCleanerJob();
    assertEquals( mockJob, testJob );

    verify( schedulerResource.schedulerService, times( 1 ) ).getContentCleanerJob();
  }

  @Test
  public void testGetContentCleanerJobError() throws Exception {
    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).getContentCleanerJob();

    try {
      schedulerResource.getContentCleanerJob();
      fail();
    } catch ( RuntimeException e ) {
      // correct
    }

    verify( schedulerResource.schedulerService, times( 1 ) ).getContentCleanerJob();
  }

  @Test
  public void testGetJobs() throws Exception {
    List<Job> mockJobs = mock( List.class );
    doReturn( mockJobs ).when( schedulerResource.schedulerService ).getJobs();

    Boolean asCronString = Boolean.FALSE;

    List<Job> testJobs = schedulerResource.getJobs( asCronString );
    assertEquals( mockJobs, testJobs );

    verify( schedulerResource.schedulerService, times( 1 ) ).getJobs();
  }

  @Test
  public void testGetJobsError() throws Exception {
    Boolean asCronString = Boolean.FALSE;

    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).getJobs();

    try {
      schedulerResource.getJobs( asCronString );
      fail();
    } catch ( RuntimeException e ) {
      // correct
    }

    verify( schedulerResource.schedulerService, times( 1 ) ).getJobs();
  }

  @Test
  public void testIsScheduleAllowed() {
    String id = "id";

    boolean isScheduleAllowed = true;
    doReturn( isScheduleAllowed ).when( schedulerResource.schedulerService ).isScheduleAllowed( id );

    String testResult = schedulerResource.isScheduleAllowed( id );
    assertEquals( "" + isScheduleAllowed, testResult );

    verify( schedulerResource.schedulerService, times( 1 ) ).isScheduleAllowed( id );
  }

  @Test
  public void testDoGetCanSchedule() {
    String canSchedule = "true";
    doReturn( canSchedule ).when( schedulerResource.schedulerService ).doGetCanSchedule();

    String testResult = schedulerResource.doGetCanSchedule();
    assertEquals( canSchedule, testResult );

    verify( schedulerResource.schedulerService, times( 1 ) ).doGetCanSchedule();
  }

  @Test
  public void testGetState() throws Exception {
    String state = "state";
    doReturn( state ).when( schedulerResource.schedulerService ).getState();

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildPlainTextOkResponse( state );

    Response testResult = schedulerResource.getState();
    assertEquals( mockResponse, testResult );

    verify( schedulerResource.schedulerService, times( 1 ) ).getState();
    verify( schedulerResource, times( 1 ) ).buildPlainTextOkResponse( state );
  }

  @Test
  public void testGetStateError() throws Exception {
    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).getState();

    try {
      schedulerResource.getState();
      fail();
    } catch ( RuntimeException e ) {
      // correct
    }

    verify( schedulerResource.schedulerService, times( 1 ) ).getState();
  }

  @Test
  public void testStart() throws Exception {
    String status = "state";
    doReturn( status ).when( schedulerResource.schedulerService ).start();

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildPlainTextOkResponse( status );

    Response testResult = schedulerResource.start();
    assertEquals( mockResponse, testResult );

    verify( schedulerResource.schedulerService, times( 1 ) ).start();
    verify( schedulerResource, times( 1 ) ).buildPlainTextOkResponse( status );
  }

  @Test
  public void testStartError() throws Exception {
    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).start();

    try {
      schedulerResource.start();
      fail();
    } catch ( RuntimeException e ) {
      // correct
    }

    verify( schedulerResource.schedulerService, times( 1 ) ).start();
  }

  @Test
  public void testPause() throws Exception {
    String status = "state";
    doReturn( status ).when( schedulerResource.schedulerService ).pause();

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildPlainTextOkResponse( status );

    Response testResult = schedulerResource.pause();
    assertEquals( mockResponse, testResult );

    verify( schedulerResource.schedulerService, times( 1 ) ).pause();
    verify( schedulerResource, times( 1 ) ).buildPlainTextOkResponse( status );
  }

  @Test
  public void testPauseError() throws Exception {
    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).pause();

    try {
      schedulerResource.pause();
      fail();
    } catch ( RuntimeException e ) {
      // correct
    }

    verify( schedulerResource.schedulerService, times( 1 ) ).pause();
  }

  @Test
  public void testShutdown() throws Exception {
    String status = "state";
    doReturn( status ).when( schedulerResource.schedulerService ).shutdown();

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildPlainTextOkResponse( status );

    Response testResult = schedulerResource.shutdown();
    assertEquals( mockResponse, testResult );

    verify( schedulerResource.schedulerService, times( 1 ) ).shutdown();
    verify( schedulerResource, times( 1 ) ).buildPlainTextOkResponse( status );
  }

  @Test
  public void testShutdownError() throws Exception {
    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).shutdown();

    try {
      schedulerResource.shutdown();
      fail();
    } catch ( RuntimeException e ) {
      // correct
    }

    verify( schedulerResource.schedulerService, times( 1 ) ).shutdown();
  }

  @Test
  public void testGetJobState() throws Exception {
    JobRequest mockJobRequest = mock( JobRequest.class );

    Job.JobState mockJobState = Job.JobState.BLOCKED;
    doReturn( mockJobState ).when( schedulerResource.schedulerService ).getJobState( mockJobRequest );

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildPlainTextOkResponse( mockJobState.name() );

    Response testResponse = schedulerResource.getJobState( mockJobRequest );
    assertEquals( mockResponse, testResponse );

    verify( schedulerResource.schedulerService, times( 1 ) ).getJobState( mockJobRequest );
    verify( schedulerResource, times( 1 ) ).buildPlainTextOkResponse( mockJobState.name() );
  }

  @Test
  public void testGetJobStateError() throws Exception {
    JobRequest mockJobRequest = mock( JobRequest.class );

    Response mockUnauthorizedResponse = mock( Response.class );
    doReturn( mockUnauthorizedResponse ).when( schedulerResource ).buildPlainTextStatusResponse( UNAUTHORIZED );

    // Test 1
    UnsupportedOperationException mockUnsupportedOperationException = mock( UnsupportedOperationException.class );
    doThrow( mockUnsupportedOperationException ).when( schedulerResource.schedulerService )
      .getJobState( mockJobRequest );

    Response testResponse = schedulerResource.getJobState( mockJobRequest );
    assertEquals( mockUnauthorizedResponse, testResponse );

    // Test 2
    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).getJobState( mockJobRequest );

    try {
      schedulerResource.getJobState( mockJobRequest );
      fail();
    } catch ( RuntimeException e ) {
      // correct
    }

    verify( schedulerResource, times( 1 ) ).buildPlainTextStatusResponse( UNAUTHORIZED );
    verify( schedulerResource.schedulerService, times( 2 ) ).getJobState( mockJobRequest );
  }

  @Test
  public void testPauseJob() throws Exception {
    String jobId = "jobId";

    JobRequest mockJobRequest = mock( JobRequest.class );
    doReturn( jobId ).when( mockJobRequest ).getJobId();

    Job.JobState state = Job.JobState.BLOCKED;
    doReturn( state ).when( schedulerResource.schedulerService ).pauseJob( jobId );

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildPlainTextOkResponse( state.name() );

    Response testResult = schedulerResource.pauseJob( mockJobRequest );
    assertEquals( mockResponse, testResult );

    verify( schedulerResource.schedulerService, times( 1 ) ).pauseJob( jobId );
    verify( schedulerResource, times( 1 ) ).buildPlainTextOkResponse( state.name() );
  }

  @Test
  public void testPauseJobError() throws Exception {
    String jobId = "jobId";

    JobRequest mockJobRequest = mock( JobRequest.class );
    doReturn( jobId ).when( mockJobRequest ).getJobId();

    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).pauseJob( jobId );

    try {
      schedulerResource.pauseJob( mockJobRequest );
      fail();
    } catch ( RuntimeException e ) {
      // correct
    }

    verify( schedulerResource.schedulerService, times( 1 ) ).pauseJob( jobId );
  }

  @Test
  public void testResumeJob() throws Exception {
    String jobId = "jobId";

    JobRequest mockJobRequest = mock( JobRequest.class );
    doReturn( jobId ).when( mockJobRequest ).getJobId();

    Job.JobState state = Job.JobState.BLOCKED;
    doReturn( state ).when( schedulerResource.schedulerService ).resumeJob( jobId );

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildPlainTextOkResponse( state.name() );

    Response testResult = schedulerResource.resumeJob( mockJobRequest );
    assertEquals( mockResponse, testResult );

    verify( schedulerResource.schedulerService, times( 1 ) ).resumeJob( jobId );
    verify( schedulerResource, times( 1 ) ).buildPlainTextOkResponse( state.name() );
  }

  @Test
  public void testResumeJobError() throws Exception {
    String jobId = "jobId";

    JobRequest mockJobRequest = mock( JobRequest.class );
    doReturn( jobId ).when( mockJobRequest ).getJobId();

    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).resumeJob( jobId );

    try {
      schedulerResource.resumeJob( mockJobRequest );
      fail();
    } catch ( RuntimeException e ) {
      // correct
    }

    verify( schedulerResource.schedulerService, times( 1 ) ).resumeJob( jobId );
  }

  @Test
  public void testRemoveJob() throws Exception {
    JobRequest mockJobRequest = mock( JobRequest.class );

    String jobId = "jobId";
    doReturn( jobId ).when( mockJobRequest ).getJobId();

    Job mockJob = mock( Job.class );
    doReturn( mockJob ).when( schedulerResource.schedulerService ).getJob( jobId );

    Job.JobState mockJobState = Job.JobState.BLOCKED;
    doReturn( mockJobState ).when( mockJob ).getState();

    Response mockRemovedResponse = mock( Response.class );
    doReturn( mockRemovedResponse ).when( schedulerResource ).buildPlainTextOkResponse( "REMOVED" );

    Response mockJobStateResponse = mock( Response.class );
    doReturn( mockJobStateResponse ).when( schedulerResource ).buildPlainTextOkResponse( mockJobState.name() );

    // Test 1
    doReturn( true ).when( schedulerResource.schedulerService ).removeJob( jobId );

    Response testResponse = schedulerResource.removeJob( mockJobRequest );
    assertEquals( mockRemovedResponse, testResponse );

    // Test 2
    doReturn( false ).when( schedulerResource.schedulerService ).removeJob( jobId );
    testResponse = schedulerResource.removeJob( mockJobRequest );
    assertEquals( mockJobStateResponse, testResponse );

    verify( mockJobRequest, times( 3 ) ).getJobId();
    verify( schedulerResource.schedulerService, times( 1 ) ).getJob( jobId );
    verify( mockJob, times( 1 ) ).getState();
    verify( schedulerResource, times( 1 ) ).buildPlainTextOkResponse( "REMOVED" );
    verify( schedulerResource, times( 1 ) ).buildPlainTextOkResponse( mockJobState.name() );
  }

  @Test
  public void testRemoveJobError() throws Exception {
    String jobId = "jobId";

    JobRequest mockJobRequest = mock( JobRequest.class );
    doReturn( jobId ).when( mockJobRequest ).getJobId();

    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).removeJob( jobId );

    try {
      schedulerResource.removeJob( mockJobRequest );
      fail();
    } catch ( RuntimeException e ) {
      // correct
    }

    verify( schedulerResource.schedulerService, times( 1 ) ).removeJob( jobId );
  }

  @Test
  public void testGetJob() throws Exception {
    String jobId = "jobId";
    String asCronString = "asCronString";

    Job mockJob = mock( Job.class );
    doReturn( mockJob ).when( schedulerResource.schedulerService ).getJobInfo( jobId );

    Job testJob = schedulerResource.getJob( jobId, asCronString );
    assertEquals( mockJob, testJob );

    verify( schedulerResource.schedulerService, times( 1 ) ).getJobInfo( jobId );
  }

  @Test
  public void testGetJobError() throws Exception {
    String jobId = "jobId";
    String asCronString = "asCronString";

    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).getJobInfo( jobId );

    try {
      schedulerResource.getJob( jobId, asCronString );
      fail();
    } catch ( RuntimeException e ) {
      // correct
    }

    verify( schedulerResource.schedulerService, times( 1 ) ).getJobInfo( jobId );
  }

  @Test
  public void testGetJobInfo() {
    JobScheduleRequest mockJobScheduleRequest = mock( JobScheduleRequest.class );
    doReturn( mockJobScheduleRequest ).when( schedulerResource.schedulerService ).getJobInfo();

    JobScheduleRequest testJobScheduleRequest = schedulerResource.getJobInfo();
    assertEquals( mockJobScheduleRequest, testJobScheduleRequest );

    verify( schedulerResource.schedulerService, times( 1 ) ).getJobInfo();
  }

  @Test
  public void testGetBlockoutJobs() {
    List<Job> mockJobs = mock( List.class );
    doReturn( mockJobs ).when( schedulerResource.schedulerService ).getBlockOutJobs();

    List<Job> blockoutJobs = schedulerResource.getBlockoutJobs();
    assertNotNull( blockoutJobs );

    verify( schedulerResource, times( 1 ) ).getBlockoutJobs();
  }

  @Test
  public void testHasBlockouts() {
    Boolean hasBlockouts = Boolean.FALSE;
    doReturn( hasBlockouts ).when( schedulerResource.schedulerService ).hasBlockouts();

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildOkResponse( hasBlockouts.toString() );

    Response testResponse = schedulerResource.hasBlockouts();
    assertEquals( mockResponse, testResponse );

    verify( schedulerResource.schedulerService, times( 1 ) ).hasBlockouts();
    verify( schedulerResource, times( 1 ) ).buildOkResponse( hasBlockouts.toString() );
  }

  @Test
  public void testAddBlockout() throws Exception {
    JobScheduleRequest mockJobScheduleRequest = mock( JobScheduleRequest.class );

    Job mockJob = mock( Job.class );
    doReturn( mockJob ).when( schedulerResource.schedulerService ).addBlockout( mockJobScheduleRequest );

    String jobId = "jobId";
    doReturn( jobId ).when( mockJob ).getJobId();

    Response mockJobResponse = mock( Response.class );
    doReturn( mockJobResponse ).when( schedulerResource ).buildPlainTextOkResponse( jobId );

    Response testResponse = schedulerResource.addBlockout( mockJobScheduleRequest );
    assertEquals( mockJobResponse, testResponse );

    verify( schedulerResource.schedulerService, times( 1 ) ).addBlockout( mockJobScheduleRequest );
    verify( mockJob, times( 1 ) ).getJobId();
    verify( schedulerResource, times( 1 ) ).buildPlainTextOkResponse( jobId );
  }

  @Test
  public void testAddBlockoutError() throws Exception {
    JobScheduleRequest mockJobScheduleRequest = mock( JobScheduleRequest.class );

    Response mockUnauthorizedResponse = mock( Response.class );
    doReturn( mockUnauthorizedResponse ).when( schedulerResource ).buildStatusResponse( UNAUTHORIZED );

    // Test 1
    IOException mockIOException = mock( IOException.class );
    doThrow( mockIOException ).when( schedulerResource.schedulerService ).addBlockout( mockJobScheduleRequest );

    Response testResponse = schedulerResource.addBlockout( mockJobScheduleRequest );
    assertEquals( mockUnauthorizedResponse, testResponse );

    // Test 2
    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).addBlockout( mockJobScheduleRequest );

    testResponse = schedulerResource.addBlockout( mockJobScheduleRequest );
    assertEquals( mockUnauthorizedResponse, testResponse );

    // Test 3
    IllegalAccessException mockIllegalAccessException = mock( IllegalAccessException.class );
    doThrow( mockIllegalAccessException ).when( schedulerResource.schedulerService )
      .addBlockout( mockJobScheduleRequest );

    testResponse = schedulerResource.addBlockout( mockJobScheduleRequest );
    assertEquals( mockUnauthorizedResponse, testResponse );

    verify( schedulerResource.schedulerService, times( 3 ) ).addBlockout( mockJobScheduleRequest );
    verify( schedulerResource, times( 3 ) ).buildStatusResponse( UNAUTHORIZED );
  }

  @Test
  public void testUpdateBlockout() throws Exception {
    String jobId = "jobId";
    JobScheduleRequest mockJobScheduleRequest = mock( JobScheduleRequest.class );

    doReturn( true ).when( schedulerResource.schedulerService ).isScheduleAllowed();

    JobRequest mockJobRequest = mock( JobRequest.class );
    doReturn( mockJobRequest ).when( schedulerResource ).getJobRequest();

    Job mockJob = mock( Job.class );
    doReturn( mockJob ).when( schedulerResource.schedulerService ).updateBlockout( jobId, mockJobScheduleRequest );

    doReturn( jobId ).when( mockJob ).getJobId();

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildPlainTextOkResponse( jobId );

    Response testResponse = schedulerResource.updateBlockout( jobId, mockJobScheduleRequest );
    assertEquals( mockResponse, testResponse );

    verify( schedulerResource.schedulerService, times( 1 ) ).updateBlockout( jobId, mockJobScheduleRequest );
    verify( mockJob, times( 1 ) ).getJobId();
  }

  @Test
  public void testUpdateBlockoutError() throws Exception {
    String jobId = "jobId";
    JobScheduleRequest mockJobScheduleRequest = mock( JobScheduleRequest.class );

    Response mockUnauthorizedResponse = mock( Response.class );
    doReturn( mockUnauthorizedResponse ).when( schedulerResource ).buildStatusResponse( UNAUTHORIZED );

    // Test 1
    IOException mockIOException = mock( IOException.class );
    doThrow( mockIOException ).when( schedulerResource.schedulerService ).updateBlockout( jobId,
      mockJobScheduleRequest );

    Response testResponse = schedulerResource.updateBlockout( jobId, mockJobScheduleRequest );
    assertEquals( mockUnauthorizedResponse, testResponse );

    // Test 2
    SchedulerException mockSchedulerException = mock( SchedulerException.class );
    doThrow( mockSchedulerException ).when( schedulerResource.schedulerService ).updateBlockout( jobId,
      mockJobScheduleRequest );

    testResponse = schedulerResource.updateBlockout( jobId, mockJobScheduleRequest );
    assertEquals( mockUnauthorizedResponse, testResponse );

    // Test 3
    IllegalAccessException mockIllegalAccessException = mock( IllegalAccessException.class );
    doThrow( mockIllegalAccessException ).when( schedulerResource.schedulerService )
      .updateBlockout( jobId, mockJobScheduleRequest );

    testResponse = schedulerResource.updateBlockout( jobId, mockJobScheduleRequest );
    assertEquals( mockUnauthorizedResponse, testResponse );

    verify( schedulerResource.schedulerService, times( 3 ) ).updateBlockout( jobId, mockJobScheduleRequest );
    verify( schedulerResource, times( 3 ) ).buildStatusResponse( UNAUTHORIZED );
  }

  @Test
  public void testBlockoutWillFire() throws Exception {
    JobScheduleRequest mockJobScheduleRequest = mock( JobScheduleRequest.class );

    IJobTrigger mockJobTrigger = mock( IJobTrigger.class );
    doReturn( mockJobTrigger ).when( schedulerResource ).convertScheduleRequestToJobTrigger( mockJobScheduleRequest );

    Boolean willFire = Boolean.FALSE;
    doReturn( willFire ).when( schedulerResource.schedulerService ).willFire( mockJobTrigger );

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildOkResponse( willFire.toString() );

    Response testResponse = schedulerResource.blockoutWillFire( mockJobScheduleRequest );
    assertEquals( mockResponse, testResponse );

    verify( schedulerResource, times( 1 ) ).convertScheduleRequestToJobTrigger( mockJobScheduleRequest );
    verify( schedulerResource.schedulerService, times( 1 ) ).willFire( mockJobTrigger );
    verify( schedulerResource, times( 1 ) ).buildOkResponse( willFire.toString() );
  }

  @Test
  public void testBlockoutWillFireError() throws Exception {
    JobScheduleRequest mockJobScheduleRequest = mock( JobScheduleRequest.class );

    UnifiedRepositoryException mockUnifiedRepositoryException = mock( UnifiedRepositoryException.class );

    SchedulerException mockSchedulerException = mock( SchedulerException.class );

    Response mockUnifiedRepositoryExceptionResponse = mock( Response.class );
    doReturn( mockUnifiedRepositoryExceptionResponse ).when( schedulerResource )
      .buildServerErrorResponse( mockUnifiedRepositoryException );

    Response mockSchedulerExceptionResponse = mock( Response.class );
    doReturn( mockSchedulerExceptionResponse ).when( schedulerResource )
      .buildServerErrorResponse( mockSchedulerException );

    // Test 1
    doThrow( mockUnifiedRepositoryException ).when( schedulerResource )
      .convertScheduleRequestToJobTrigger( mockJobScheduleRequest );

    Response testResponse = schedulerResource.blockoutWillFire( mockJobScheduleRequest );
    assertEquals( mockUnifiedRepositoryExceptionResponse, testResponse );

    // Test 2
    doThrow( mockSchedulerException ).when( schedulerResource )
      .convertScheduleRequestToJobTrigger( mockJobScheduleRequest );

    testResponse = schedulerResource.blockoutWillFire( mockJobScheduleRequest );
    assertEquals( mockSchedulerExceptionResponse, testResponse );

    verify( schedulerResource, times( 1 ) ).buildServerErrorResponse( mockUnifiedRepositoryException );
    verify( schedulerResource, times( 1 ) ).buildServerErrorResponse( mockSchedulerException );
    verify( schedulerResource, times( 2 ) ).convertScheduleRequestToJobTrigger( mockJobScheduleRequest );
  }

  @Test
  public void testShouldFireNow() {
    Boolean shouldFireNow = Boolean.FALSE;
    doReturn( shouldFireNow ).when( schedulerResource.schedulerService ).shouldFireNow();

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildOkResponse( shouldFireNow.toString() );

    Response testResponse = schedulerResource.shouldFireNow();
    assertEquals( mockResponse, testResponse );

    verify( schedulerResource.schedulerService, times( 1 ) ).shouldFireNow();
    verify( schedulerResource, times( 1 ) ).buildOkResponse( shouldFireNow.toString() );
  }

  @Test
  public void testGetBlockStatus() throws Exception {
    JobScheduleRequest mockJobScheduleRequest = mock( JobScheduleRequest.class );

    BlockStatusProxy mockBlockStatusProxy = mock( BlockStatusProxy.class );
    doReturn( mockBlockStatusProxy ).when( schedulerResource.schedulerService )
      .getBlockStatus( mockJobScheduleRequest );

    Response mockResponse = mock( Response.class );
    doReturn( mockResponse ).when( schedulerResource ).buildOkResponse( mockBlockStatusProxy );

    Response testResponse = schedulerResource.getBlockStatus( mockJobScheduleRequest );
    assertEquals( mockResponse, testResponse );

    verify( schedulerResource.schedulerService, times( 1 ) ).getBlockStatus( mockJobScheduleRequest );
    verify( schedulerResource, times( 1 ) ).buildOkResponse( mockBlockStatusProxy );
  }


  @Test
  public void updateJob_ReturnsJobId() throws Exception {
    JobScheduleRequest request = new JobScheduleRequest();
    Job job = new Job();
    job.setJobId( "job-id" );
    when( schedulerResource.schedulerService.updateJob( request ) ).thenReturn( job );

    assertUpdateJob( request, OK, job.getJobId() );
  }

  @Test
  public void updateJob_Returns500_WhenSchedulerFails() throws Exception {
    JobScheduleRequest request = new JobScheduleRequest();
    when( schedulerResource.schedulerService.updateJob( request ) )
      .thenThrow( new SchedulerException( new RuntimeException( "error" ) ) );

    assertUpdateJob( request, INTERNAL_SERVER_ERROR, "error" );
  }

  @Test
  public void updateJob_Returns500_WhenIoFails() throws Exception {
    JobScheduleRequest request = new JobScheduleRequest();
    when( schedulerResource.schedulerService.updateJob( request ) )
      .thenThrow( new IOException( new RuntimeException( "error" ) ) );

    assertUpdateJob( request, INTERNAL_SERVER_ERROR, "error" );
  }

  @Test
  public void updateJob_Returns401_WhenNotAuthorized() throws Exception {
    JobScheduleRequest request = new JobScheduleRequest();
    when( schedulerResource.schedulerService.updateJob( request ) )
      .thenThrow( new SecurityException( "error" ) );

    assertUpdateJob( request, UNAUTHORIZED, null );
  }

  @Test
  public void updateJob_Returns403_WhenNotPermitted() throws Exception {
    JobScheduleRequest request = new JobScheduleRequest();
    when( schedulerResource.schedulerService.updateJob( request ) )
      .thenThrow( new IllegalAccessException( "error" ) );

    assertUpdateJob( request, FORBIDDEN, null );
  }

  private void assertUpdateJob( JobScheduleRequest request, Response.Status expectedStatus, String expectedResponse ) {
    Response response = schedulerResource.updateJob( request );
    assertEquals( expectedStatus.getStatusCode(), response.getStatus() );
    assertEquals( expectedResponse, response.getEntity() );
  }
}