Difficult to test example refactoring

 /**
   * called before the associated job has been executed to check whether a lock
   * file is present that indicates that another extraction request has not completed yet
   * @param context
   * @param jobException
   */
 public static boolean isExtractionInProgress(Properties props, String pJobName, boolean pCreateLockFile) {
   boolean debug = log.isDebugEnabled();
   boolean isExtractionInProgress = true; // block by default

  try {
    if (props!=null) {
      String lock_file_name = props.getProperty(pJobName + PericlesJobScheduler.LOCK_FILE_NAME_KEY);

      if (lock_file_name == null) {
        log.error("No job level lock file name found, key used: " + pJobName + PericlesJobScheduler.LOCK_FILE_NAME_KEY);
      } else {
        String sys_base_path = PropertyManager.getInstance(true).getBasePath();

        if (debug)
           log.debug("lock_file_name: " + lock_file_name);
        File lockFile = new File(sys_base_path + lock_file_name);
        if (lockFile.exists()) {
           if (debug)
              log.debug("lock file exists: extraction already in progress");
        } else {
           if (debug)
             log.debug("lock file does not exist");

           if (pCreateLockFile) {
               if (lockFile.createNewFile()) {
                  if (debug)
                    log.debug("Created lock file");
                  } else {
                    log.error("Can not create job lock file");
                  }
               }
               isExtractionInProgress = false;
           }
        }
    } else {
       log.error("Can not check lock file: no props found");
    }
  }
  catch (Exception ex) {
    log.error("Can not update job completed 'flag' file", ex);
  }
  return isExtractionInProgress;
}

   public static boolean isExtractionInProgress(Properties props, 
                 String pJobName, boolean pCreateLockFile) {
     return isExtractionInProgress(props, pJobName, pCreateLockFile, PropertyManager.getInstance(true));
   }
 
   public static boolean isExtractionInProgress(Properties props, 
                 String pJobName, boolean pCreateLockFile, PropertyManager propertyManager) {
     boolean isExtractionInProgress = true;
     try {
      Preconditions.checkNotNull(propertyManager);
      isExtractionInProgress_paramCheck(props, pJobName);
    } catch (Exception e) {
      log.error(e.getMessage(), e);
      return isExtractionInProgress;
    }
    final String key = pJobName + PericlesJobScheduler.LOCK_FILE_NAME_KEY;
    final String lock_file_name = props.getProperty(key);
    final String sys_base_path = propertyManager.getBasePath();
    File lockFile = new File(sys_base_path + lock_file_name);
    try {
      if (lockFile.exists()) {
        return isExtractionInProgress;
      }
      if (pCreateLockFile) {
        lockFile.createNewFile())
      }
      isExtractionInProgress = false;
    } catch (Exception ex) {;}
    return isExtractionInProgress;
  }

  static void isExtractionInProgress_paramCheck(Properties props, String pJobName) {
    if (null == props) {
      throw new NullPointerException("Can not check lock file: no props found");
    }
    final String key = pJobName + PericlesJobScheduler.LOCK_FILE_NAME_KEY;
    if (!props.containsKey(key) || null == props.getProperty(key)) {
      throw new NullPointerException(
                "No job level lock file name found, key used: " + 
                pJobName + 
                PericlesJobScheduler.LOCK_FILE_NAME_KEY);
    }
  }

 public class JobUtils_isExtractionInProgress_Test {
   Properties prop;
   PropertyManager propertyManager;
   File rootDir;
   File lockFile;
   String newLockFileName = "newLockfile.txt";
 
   @Before
   public void setup() throws Exception {
    prop = new Properties();
    rootDir = createTempDirectory();
    lockFile = new File(rootDir, "testLockFile.txt");
    lockFile.createNewFile();
    propertyManager = mock(PropertyManager.class);
  }

  @After
  public void teardown() throws Exception {
    lockFile.delete();
    new File(rootDir, newLockFileName).delete();
    rootDir.delete();

  }

  public static File createTempDirectory() throws IOException {
    final File temp;
    temp = File.createTempFile("temp", Long.toString(System.nanoTime()));
    if (!(temp.delete())) {
      throw new IOException("Could not delete temp file: " + temp.getAbsolutePath());
    }
    if (!(temp.mkdir())) {
      throw new IOException("Could not create temp directory: " + temp.getAbsolutePath());
    }
    return (temp);
  }

 @Test
  public void no_property() {
    new AssertThrows(NullPointerException.class) {
      @Override
      public void test() throws Exception {
        isExtractionInProgress_paramCheck(null, null);
      }
    }.runTest();
  }

  @Test
  public void inpropert_job_name() throws Exception {
    new AssertThrows(NullPointerException.class) {
      @Override
      public void test() throws Exception {
        isExtractionInProgress_paramCheck(prop, null);
      }
    }.runTest();
  }

  @Test
  public void lock_exists() throws Exception {
    prop.setProperty("nullJobLockFileNameKey", lockFile.getName());
    when(propertyManager.getBasePath()).thenReturn(rootDir.getAbsolutePath() + File.separator);
    assertTrue(isExtractionInProgress(prop, null, false, propertyManager));
  }

  @Test
  public void lock_not_exists() throws Exception {
    prop.setProperty("nullJobLockFileNameKey", newLockFileName);
    when(propertyManager.getBasePath()).thenReturn(rootDir.getAbsolutePath() + File.separator);
    assertFalse(isExtractionInProgress(prop, null, false, propertyManager));
  }
}

   public static boolean isExtractionInProgress(Properties props, String pJobName, boolean pCreateLockFile, PropertyManager propertyManager) {
     return new FileLocking(props, pJobName, pCreateLockFile, propertyManager).isExtractionInProgress();
   }
 
   static class FileLocking {
     private final Properties props;
     private final String pJobName;
     private final boolean pCreateLockFile;
     private final PropertyManager propertyManager;

    public FileLocking(Properties props, String pJobName, boolean pCreateLockFile, PropertyManager propertyManager) {
      super();
      this.props = props;
      this.pJobName = pJobName;
      this.pCreateLockFile = pCreateLockFile;
      this.propertyManager = propertyManager;
    }

    public boolean isExtractionInProgress() {
      isExtractionInProgress_paramCheck();
      Preconditions.checkNotNull(propertyManager);
      boolean isExtractionInProgress = true; // block by default
      final String key = pJobName + PericlesJobScheduler.LOCK_FILE_NAME_KEY;
      final String lock_file_name = props.getProperty(key);
      final String sys_base_path = propertyManager.getBasePath();
      final File lockFile = new File(sys_base_path + lock_file_name);
      try {
        if (lockFile.exists()) {
          return isExtractionInProgress;
        }
        if (pCreateLockFile) {
          if (lockFile.createNewFile()) {}else {}
        }
        isExtractionInProgress = false;
      } catch (Exception ex) {
      }
      return isExtractionInProgress;
    }

    void isExtractionInProgress_paramCheck() {
      if (null == props) {
        throw new NullPointerException("Can not check lock file: no props found");
      }
      final String key = pJobName + PericlesJobScheduler.LOCK_FILE_NAME_KEY;
      if (!props.containsKey(key) || null == props.getProperty(key)) {
        throw new NullPointerException("No job level lock file name found, key used: " + pJobName
            + PericlesJobScheduler.LOCK_FILE_NAME_KEY);
      }
    }
  }

 public static boolean isExtractionInProgress(Properties props, String pJobName, boolean pCreateLockFile, PropertyManager propertyManager) {
     try {
       return new FileLocking(props, pJobName, pCreateLockFile, propertyManager).checkLockOrCreate();
     } catch (Exception e) {
       log.error(e, e);
       return true;//??? !!!! ???
     }
   }
 
  static class FileLocking {
    private final Properties props;
    private final String pJobName;
    private final boolean pCreateLockFile;
    private final PropertyManager propertyManager;

    public FileLocking(Properties props, String pJobName, boolean pCreateLockFile, PropertyManager propertyManager) {
      super();
      this.props = props;
      this.pJobName = pJobName;
      this.pCreateLockFile = pCreateLockFile;
      this.propertyManager = propertyManager;
    }

    public boolean checkLockOrCreate() {
      isExtractionInProgress_paramCheck();
      Preconditions.checkNotNull(propertyManager);
      boolean isExtractionInProgress = true; // block by default
      final String key = pJobName + PericlesJobScheduler.LOCK_FILE_NAME_KEY;
      final String lock_file_name = props.getProperty(key);
      final String sys_base_path = propertyManager.getBasePath();
      final File lockFile = getLockFile(lock_file_name, sys_base_path);
      try {
        if (lockFile.exists()) {
          log.debug("lock file exists: extraction already in progress");
          return isExtractionInProgress;
        }
        log.debug("lock file does not exist");
        if (pCreateLockFile) {
          if (lockFile.createNewFile()) {}else {}
        }
        isExtractionInProgress = false;
      } catch (Exception ex) {}
      return isExtractionInProgress;
    }

    File getLockFile(final String lock_file_name, final String sys_base_path) {
      return new File(sys_base_path + lock_file_name);
    }

    void isExtractionInProgress_paramCheck() {
      if (null == props) {
        throw new NullPointerException("Can not check lock file: no props found");
      }
      final String key = pJobName + PericlesJobScheduler.LOCK_FILE_NAME_KEY;
      if (!props.containsKey(key) || null == props.getProperty(key)) {
        throw new NullPointerException("No job level lock file name found, key used: " + pJobName
            + PericlesJobScheduler.LOCK_FILE_NAME_KEY);
      }
    }

  }

   @Test
   public void non_readable_file_or_folder() throws Exception {
     prop.setProperty("nullJobLockFileNameKey", lockFile.getName());
     FileLocking subject = new FileLocking(prop, null, false, propertyManager) {
       @Override
       File getLockFile(String lock_file_name, String sys_base_path) {
         File r = mock(File.class);
         when(r.exists()).thenThrow(new SecurityException("fake security exception for `File.exists()`"));
         return r;
      }
    };
    assertTrue("Are we sure that this is the correct behavior??????", subject.checkLockOrCreate());
  }

  @Test
  public void non_writable_folder() throws Exception {
    prop.setProperty("nullJobLockFileNameKey", lockFile.getName());
    FileLocking subject = new FileLocking(prop, null, true, propertyManager) {
      @Override
      File getLockFile(String lock_file_name, String sys_base_path) {
        File r = mock(File.class);
        try {
          when(r.exists()).thenReturn(false);
          when(r.createNewFile()).thenThrow(new SecurityException("fake security exception for `File.createNewFile()`"));
        } catch (IOException e) {
          throw Throwables.propagate(e);
        }
        return r;
      }
    };
    assertTrue("Are we sure that this is the correct behavior??????", subject.checkLockOrCreate());
  }