How to use

net.groboclown.p4.server.api.commands.file.DeleteFileAction

constructor

@Override
protected void performDeletion(List<FilePath> filesToDelete) {
  VcsFileUtil.markFilesDirty(myProject, filesToDelete);
  final List<VirtualFile> affectedFiles = filesToDelete.stream().map(FilePath::getVirtualFile)
      .collect(Collectors.toList());
      Map<ClientServerRef, P4ChangelistId> activeChangelistIds = getActiveChangelistIds();
  for (FilePath filePath : filesToDelete) {
    ClientConfigRoot root = getClientFor(filePath);
    if (root != null) {
      P4ChangelistId id = getActiveChangelistFor(root, activeChangelistIds);
      if (LOG.isDebugEnabled()) {
        LOG.debug("Opening for delete: " + filePath + " (@" + id + ")");
      }
      P4ServerComponent
      .perform(myProject, root.getClientConfig(),
          new DeleteFileAction(filePath, id))
      .whenAnyState(() -> {
        if (LOG.isDebugEnabled()) {
          LOG.debug("Completed call to delete file " + filesToDelete);
        }
      });
    } else {
      LOG.info("Skipped deleting " + filePath + "; not under known P4 client");
    }
  }
}

@Test
void curateFile_delete_delete_sameCl() {
  PendingActionCurator.PendingActionFactory actionFactory = mock(PendingActionCurator.PendingActionFactory.class);
  PendingActionCurator curator = new PendingActionCurator(actionFactory);
  List<ActionStore.PendingAction> actions = new ArrayList<>();
  P4ChangelistIdImpl cl1 = new P4ChangelistIdImpl(100, REF_A1);
  Map<String, MockVirtualFile> fs = MockVirtualFileSystem.createTree(
      "a.txt", "abc"
  );
  MockVirtualFile f1 = fs.get("a.txt");
  ActionStore.PendingAction firstDelete = ActionStore.createPendingAction(REF_A1,
      new DeleteFileAction(f1.asFilePath(), cl1));
  actions.add(firstDelete);
  ActionStore.PendingAction secondDelete = ActionStore.createPendingAction(REF_A1,
      new DeleteFileAction(f1.asFilePath(), cl1));
  curator.curateActionList(secondDelete, actions);
  // The first delete should be curated, so that the intention of the second delete's changelist is maintained.
  assertContainsExactly(actions, firstDelete);
}

@Test
void curateFile_delete_delete_diffCl() {
  PendingActionCurator.PendingActionFactory actionFactory = mock(PendingActionCurator.PendingActionFactory.class);
  PendingActionCurator curator = new PendingActionCurator(actionFactory);
  List<ActionStore.PendingAction> actions = new ArrayList<>();
  P4ChangelistIdImpl cl1 = new P4ChangelistIdImpl(100, REF_A1);
  P4ChangelistIdImpl cl2 = new P4ChangelistIdImpl(101, REF_A1);
  Map<String, MockVirtualFile> fs = MockVirtualFileSystem.createTree(
      "a.txt", "abc"
  );
  MockVirtualFile f1 = fs.get("a.txt");
  ActionStore.PendingAction firstDelete = ActionStore.createPendingAction(REF_A1,
      new DeleteFileAction(f1.asFilePath(), cl1));
  actions.add(firstDelete);
  ActionStore.PendingAction secondDelete = ActionStore.createPendingAction(REF_A1,
      new DeleteFileAction(f1.asFilePath(), cl2));
  curator.curateActionList(secondDelete, actions);
  // The first delete should be curated, so that the intention of the second delete's changelist is maintained.
  assertContainsExactly(actions, secondDelete);
}

        .perform(project, root.getClientConfig(), new DeleteFileAction(file, id))
        .whenCompleted((res) -> ChangeListManager.getInstance(project).scheduleUpdate(true));
if (ApplicationManager.getApplication().isDispatchThread()) {

@Test
void curateFile_add_delete() {
  Map<String, MockVirtualFile> fs = MockVirtualFileSystem.createTree(
      "a.txt", "abc"
  );
  MockVirtualFile f1 = fs.get("a.txt");
  PendingActionCurator.PendingActionFactory actionFactory = mock(PendingActionCurator.PendingActionFactory.class);
  PendingActionCurator curator = new PendingActionCurator(actionFactory);
  List<ActionStore.PendingAction> actions = new ArrayList<>();
  P4ChangelistIdImpl cl = new P4ChangelistIdImpl(100, REF_A1);
  ActionStore.PendingAction addFile = ActionStore.createPendingAction(REF_A1, new AddEditAction(
      f1.asFilePath(), null, cl, (String) null));
  actions.add(addFile);
  ActionStore.PendingAction deleteFile =
      ActionStore.createPendingAction(REF_A1, new DeleteFileAction(f1.asFilePath(), cl));
  curator.curateActionList(deleteFile, actions);
  // Delete file cannot tell if the file was open for add or edit, so it must be left alone.
  assertContainsExactly(actions, addFile, deleteFile);
}

null,
actionFactory.create(new DeleteFileAction(ex.getSourceFile(), ex.getChangelistId())),

@Test
void curateFile_delete_add_delete() {
  SimplePendingActionFactory actionFactory = new SimplePendingActionFactory(REF_A1);
  PendingActionCurator curator = new PendingActionCurator(actionFactory);
  Map<String, MockVirtualFile> fs = MockVirtualFileSystem.createTree(
      "a.txt", "abc"
  );
  MockVirtualFile file = fs.get("a.txt");
  List<ActionStore.PendingAction> actions = new ArrayList<>();
  P4ChangelistIdImpl cl = new P4ChangelistIdImpl(100, REF_A1);
  ActionStore.PendingAction deleteFile = ActionStore.createPendingAction(REF_A1,
      new DeleteFileAction(file.asFilePath(), cl));
  actions.add(deleteFile);
  ActionStore.PendingAction addFile = ActionStore.createPendingAction(REF_A1,
      new AddEditAction(file.asFilePath(), null, cl, (String) null));
  actions.add(addFile);
  // Reuse the delete request
  curator.curateActionList(deleteFile, actions);
  // Because we stop looking with the delete -> add, the list should be maintained as expected.
  assertContainsExactly(actions, deleteFile, addFile, deleteFile);
}

@Test
void curateFile_delete_revert_add() {
  SimplePendingActionFactory actionFactory = new SimplePendingActionFactory(REF_A1);
  PendingActionCurator curator = new PendingActionCurator(actionFactory);
  Map<String, MockVirtualFile> fs = MockVirtualFileSystem.createTree(
      "a.txt", "abc"
  );
  MockVirtualFile file = fs.get("a.txt");
  List<ActionStore.PendingAction> actions = new ArrayList<>();
  P4ChangelistIdImpl cl = new P4ChangelistIdImpl(100, REF_A1);
  ActionStore.PendingAction deleteFile = ActionStore.createPendingAction(REF_A1,
      new DeleteFileAction(file.asFilePath(), cl));
  actions.add(deleteFile);
  ActionStore.PendingAction revertFile = ActionStore.createPendingAction(REF_A1,
      new RevertFileAction(file.asFilePath(), false));
  actions.add(revertFile);
  ActionStore.PendingAction addFile = ActionStore.createPendingAction(REF_A1,
      new AddEditAction(file.asFilePath(), null, cl, (String) null));
  curator.curateActionList(addFile, actions);
  // Because offline revert isn't implemented, the revert then add maintains the integrity.
  assertContainsExactly(actions, deleteFile, revertFile, addFile);
}

      state.data.getStringNullable("charset", null));
case DELETE_FILE:
  return new DeleteFileAction(state.actionId,
      state.data.getFilePathNotNull("file"),
      state.data.getChangelistIdNullable("cl-id"));

@Test
void curateFile_addTgt_moveSrc_deleteSrc() {
  SimplePendingActionFactory actionFactory = new SimplePendingActionFactory(REF_A1);
  PendingActionCurator curator = new PendingActionCurator(actionFactory);
  Map<String, MockVirtualFile> fs = MockVirtualFileSystem.createTree(
      "a.txt", "abc",
      "b.txt", "def"
  );
  MockVirtualFile src = fs.get("a.txt");
  MockVirtualFile tgt = fs.get("b.txt");
  List<ActionStore.PendingAction> actions = new ArrayList<>();
  P4ChangelistIdImpl cl1 = new P4ChangelistIdImpl(100, REF_A1);
  P4ChangelistIdImpl cl2 = new P4ChangelistIdImpl(100, REF_A1);
  ActionStore.PendingAction addFile = ActionStore.createPendingAction(REF_A1,
      new AddEditAction(tgt.asFilePath(), null, cl1, (String) null));
  actions.add(addFile);
  ActionStore.PendingAction moveFile = ActionStore.createPendingAction(REF_A1,
      new MoveFileAction(src.asFilePath(), tgt.asFilePath(), cl1));
  actions.add(moveFile);
  ActionStore.PendingAction deleteFile = ActionStore.createPendingAction(REF_A1,
      new DeleteFileAction(src.asFilePath(), cl2));
  curator.curateActionList(deleteFile, actions);
  assertSize(0, actionFactory.created);
  assertContainsExactly(actions, addFile, moveFile);
}

@Test
void curateFile_move_deleteTgt() {
  SimplePendingActionFactory actionFactory = new SimplePendingActionFactory(REF_A1);
  PendingActionCurator curator = new PendingActionCurator(actionFactory);
  Map<String, MockVirtualFile> fs = MockVirtualFileSystem.createTree(
      "a.txt", "abc",
      "b.txt", "def"
  );
  MockVirtualFile srcFile = fs.get("a.txt");
  MockVirtualFile tgtFile = fs.get("b.txt");
  List<ActionStore.PendingAction> actions = new ArrayList<>();
  P4ChangelistIdImpl cl1 = new P4ChangelistIdImpl(100, REF_A1);
  P4ChangelistIdImpl cl2 = new P4ChangelistIdImpl(100, REF_A1);
  ActionStore.PendingAction moveFile = ActionStore.createPendingAction(REF_A1,
      new MoveFileAction(srcFile.asFilePath(), tgtFile.asFilePath(), cl1));
  actions.add(moveFile);
  ActionStore.PendingAction deleteFile = ActionStore.createPendingAction(REF_A1,
      new DeleteFileAction(tgtFile.asFilePath(), cl2));
  curator.curateActionList(deleteFile, actions);
  assertSize(1, actionFactory.created);
  ActionStore.PendingAction created = actionFactory.created.get(0);
  assertContainsExactly(actions, created);
  assertNull(created.serverAction);
  assertNotNull(created.clientAction);
  assertEquals(created.clientAction.getClass(), DeleteFileAction.class);
  DeleteFileAction createdDelete = (DeleteFileAction) created.clientAction;
  assertEquals(cl1, createdDelete.getChangelistId());
}

actionFactory.create(new DeleteFileAction(existing.getSourceFile(),
    existing.getChangelistId())),
false);

actions.add(moveFile);
ActionStore.PendingAction deleteFile = ActionStore.createPendingAction(REF_A1,
    new DeleteFileAction(tgt.asFilePath(), cl2));

new DeleteFileAction(src, id)));

runner.perform(clientConfig, new DeleteFileAction(newFile,
      new P4ChangelistIdImpl(0, clientConfig.getClientServerRef())))
    .whenCompleted(sink::resolve)