Drag and Drop is a common mouse interaction used in modern web applications. It allows a user to click and hold an element, move it to another location, and release it there. In Selenium WebDriver, drag-and-drop operations can be automated using the Actions class.
Drag and Drop automation is useful when testing sortable lists, Kanban boards, dashboards, shopping carts, task-management systems, file-management interfaces, workflow applications, and other web elements that depend on mouse movement.
Selenium Training Course | Register for Course Demo
Drag and Drop is a mouse interaction in which a user selects an element, holds the mouse button, moves the pointer to another location, and releases the element.
In Selenium Java, the Actions class provides methods such as dragAndDrop(), clickAndHold(), moveToElement(), and release() for automating drag-and-drop interactions.
Many modern web applications depend on mouse-based movement. A normal click() is not sufficient when an application requires an element to be dragged from one location to another.
Selenium WebDriver provides the Actions class for advanced mouse and keyboard interactions. The simplest drag-and-drop operation can be performed using the dragAndDrop() method.
Actions actions = new Actions(driver);
actions.dragAndDrop(source, target).perform();
The Actions class is part of Selenium's interaction API. It is commonly used for advanced interactions such as mouse movement, double click, right click, drag and drop, click and hold, hover, and keyboard combinations.
Actions actions = new Actions(driver);Actions actions = new Actions(driver);
actions.dragAndDrop(sourceElement, targetElement).perform();
Here:
actions is the Actions object.dragAndDrop(sourceElement, targetElement) performs the drag-and-drop interaction.perform() executes the built interaction.import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
WebElement source = driver.findElement(By.id("source"));
WebElement target = driver.findElement(By.id("target"));
Actions actions = new Actions(driver);
actions.dragAndDrop(source, target).perform();
If both the source and target elements have unique IDs, ID locators can be used.
WebElement source = driver.findElement(By.id("dragSource"));
WebElement target = driver.findElement(By.id("dropTarget"));
new Actions(driver)
.dragAndDrop(source, target)
.perform();
WebElement source = driver.findElement(By.name("source"));
WebElement target = driver.findElement(By.name("target"));
new Actions(driver)
.dragAndDrop(source, target)
.perform();
WebElement source = driver.findElement(By.className("draggable"));
WebElement target = driver.findElement(By.className("droppable"));
new Actions(driver)
.dragAndDrop(source, target)
.perform();
WebElement source = driver.findElement(
By.cssSelector(".drag-source")
);
WebElement target = driver.findElement(
By.cssSelector(".drop-target")
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
WebElement source = driver.findElement(
By.xpath("//div[@id='source']")
);
WebElement target = driver.findElement(
By.xpath("//div[@id='target']")
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
The most common scenario is moving one WebElement onto another WebElement.
WebElement source = driver.findElement(By.id("source"));
WebElement target = driver.findElement(By.id("target"));
Actions actions = new Actions(driver);
actions.dragAndDrop(source, target).perform();
The dragAndDrop() method provides a concise way to perform a drag-and-drop interaction between two WebElements.
actions.dragAndDrop(source, target).perform();Conceptually, the operation is:
Locate Source
↓
Click and Hold
↓
Move Pointer
↓
Move to Target
↓
Release Mouse
↓
Validate Result
When the direct dragAndDrop() method does not work reliably with a custom component, the interaction can be constructed manually.
Actions actions = new Actions(driver);
actions.clickAndHold(source)
.moveToElement(target)
.release()
.perform();
new Actions(driver)
.clickAndHold(source)
.moveToElement(target)
.release()
.perform();
This approach provides more control over the individual steps of the interaction.
The release() method releases the currently held mouse button.
Actions actions = new Actions(driver);
actions.clickAndHold(source)
.moveToElement(target)
.release()
.perform();
For applications with complex drag-and-drop behavior, breaking the operation into individual actions can provide better control.
Actions actions = new Actions(driver);
actions.moveToElement(source)
.clickAndHold()
.moveToElement(target)
.release()
.perform();
| Feature | dragAndDrop() | Manual Actions |
|---|---|---|
| Code length | Short | Longer |
| Control | Less control | More control |
| Ease of use | Simple | Requires more knowledge |
| Complex UI | May require troubleshooting | Can be customized |
| Typical use | Standard drag and drop | Custom drag-and-drop components |
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.interactions.Actions;
public class DragAndDropExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
WebElement source = driver.findElement(
By.id("source")
);
WebElement target = driver.findElement(
By.id("target")
);
Actions actions = new Actions(driver);
actions.dragAndDrop(source, target).perform();
driver.quit();
}
}
Dynamic applications may require the source and target elements to become available before the interaction is performed.
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement source = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("source")
)
);
WebElement target = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("target")
)
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
import java.time.Duration;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
Using Thread.sleep() may make tests slower and does not guarantee that the required UI state has actually been reached.
Thread.sleep(3000);
actions.dragAndDrop(source, target).perform();
A condition-based explicit wait is generally preferable when synchronization is required.
Dynamic web applications may create or update source and target elements after page loading. In such cases, locate the elements after the relevant state is available.
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement source = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".dynamic-source")
)
);
WebElement target = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector(".dynamic-target")
)
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
Sortable lists allow users to rearrange items by dragging one item above or below another item.
WebElement firstItem = driver.findElement(
By.cssSelector(".sortable-item:nth-child(1)")
);
WebElement secondItem = driver.findElement(
By.cssSelector(".sortable-item:nth-child(2)")
);
new Actions(driver)
.dragAndDrop(firstItem, secondItem)
.perform();
Kanban applications commonly allow users to move tasks between columns such as To Do, In Progress, and Completed.
WebElement task = driver.findElement(
By.cssSelector(".task-card")
);
WebElement completedColumn = driver.findElement(
By.cssSelector(".completed-column")
);
new Actions(driver)
.dragAndDrop(task, completedColumn)
.perform();
An e-commerce application may allow a user to drag a product into a shopping cart.
WebElement product = driver.findElement(
By.cssSelector(".product-card")
);
WebElement cart = driver.findElement(
By.id("cart")
);
new Actions(driver)
.dragAndDrop(product, cart)
.perform();
Some web applications provide a visual drop zone where files can be dragged. When an <input type="file"> is available, Selenium's file-input support is generally more reliable than trying to automate an operating-system file drag operation.
WebElement fileInput = driver.findElement(
By.cssSelector("input[type='file']")
);
fileInput.sendKeys("/path/to/test-file.pdf");
This approach uploads the file directly instead of trying to simulate an operating-system file drag operation.
Dashboard applications may allow users to rearrange widgets by dragging them to different positions.
WebElement widget = driver.findElement(
By.id("salesWidget")
);
WebElement targetArea = driver.findElement(
By.id("dashboardArea")
);
new Actions(driver)
.dragAndDrop(widget, targetArea)
.perform();
Applications may contain separate source and destination containers. The element can be moved from one container to another.
WebElement item = driver.findElement(
By.cssSelector(".source-container .item")
);
WebElement destination = driver.findElement(
By.cssSelector(".destination-container")
);
new Actions(driver)
.dragAndDrop(item, destination)
.perform();
After performing a drag-and-drop operation, the expected result should always be validated.
new Actions(driver)
.dragAndDrop(source, target)
.perform();
WebElement result = driver.findElement(
By.id("successMessage")
);
if (result.isDisplayed()) {
System.out.println("Drag and drop successful");
}
new Actions(driver)
.dragAndDrop(source, target)
.perform();
WebElement result = driver.findElement(
By.id("successMessage")
);
Assert.assertTrue(
result.isDisplayed(),
"Expected result was not displayed after drag and drop"
);
@Test
public void verifyDragAndDrop() {
WebElement source = driver.findElement(
By.id("source")
);
WebElement target = driver.findElement(
By.id("target")
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
Assert.assertTrue(
driver.findElement(By.id("result")).isDisplayed()
);
}
In the Page Object Model, the drag-and-drop operation can be encapsulated inside the page class.
public void dragItemToTarget() {
WebElement source = driver.findElement(
By.id("source")
);
WebElement target = driver.findElement(
By.id("target")
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
}
public class KanbanPage {
private WebDriver driver;
private By task = By.id("task");
private By completedColumn = By.id("completed");
public KanbanPage(WebDriver driver) {
this.driver = driver;
}
public void moveTaskToCompleted() {
WebElement source =
driver.findElement(task);
WebElement target =
driver.findElement(completedColumn);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
}
}
@Test
public void moveTask() {
KanbanPage page =
new KanbanPage(driver);
page.moveTaskToCompleted();
}
public class ActionUtils {
private WebDriver driver;
public ActionUtils(WebDriver driver) {
this.driver = driver;
}
public void dragAndDrop(
WebElement source,
WebElement target
) {
new Actions(driver)
.dragAndDrop(source, target)
.perform();
}
}
ActionUtils actions =
new ActionUtils(driver);
WebElement source = driver.findElement(
By.id("source")
);
WebElement target = driver.findElement(
By.id("target")
);
actions.dragAndDrop(source, target);
A utility can also expose the manual action sequence for applications where direct dragAndDrop() requires customization.
public void manualDragAndDrop(
WebElement source,
WebElement target
) {
new Actions(driver)
.moveToElement(source)
.clickAndHold()
.moveToElement(target)
.release()
.perform();
}
Some applications require a short pause while the pointer is being moved. The Actions API can include pauses in the interaction sequence when appropriate.
new Actions(driver)
.moveToElement(source)
.clickAndHold()
.pause(Duration.ofMillis(500))
.moveToElement(target)
.pause(Duration.ofMillis(500))
.release()
.perform();
Complex interfaces may require the pointer to pass through an intermediate location.
new Actions(driver)
.moveToElement(source)
.clickAndHold()
.moveByOffset(100, 0)
.moveToElement(target)
.release()
.perform();
The moveByOffset() method moves the pointer relative to its current position.
new Actions(driver)
.moveToElement(source)
.clickAndHold()
.moveByOffset(200, 100)
.release()
.perform();
Coordinate-based movement should be used carefully because layout changes can affect coordinates.
Some custom interfaces require the item to be dropped at a specific position relative to a target.
new Actions(driver)
.moveToElement(source)
.clickAndHold()
.moveToElement(target, 20, 20)
.release()
.perform();
Target offsets can be useful when a drop zone responds only to a particular area of the target element.
new Actions(driver)
.clickAndHold(source)
.moveToElement(target, 30, 10)
.release()
.perform();
Modern web applications often use custom controls built with HTML, CSS, JavaScript, and frontend frameworks. Selenium can interact with these components when their drag-and-drop behavior responds correctly to WebDriver pointer actions.
WebElement source = driver.findElement(
By.cssSelector(".custom-draggable")
);
WebElement target = driver.findElement(
By.cssSelector(".custom-droppable")
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
Web applications may implement drag-and-drop behavior using JavaScript events such as dragstart, dragover, and drop.
<div id="source" draggable="true">
Drag Me
</div>
<div id="target">
Drop Here
</div>
HTML5 drag-and-drop components can sometimes behave differently from simple mouse-based components. The implementation of the web application determines whether the standard Actions sequence works correctly.
WebElement source = driver.findElement(
By.id("source")
);
WebElement target = driver.findElement(
By.id("target")
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
If a standard Actions drag-and-drop operation does not produce the expected result, investigate the application's event handling before choosing an alternative approach.
new Actions(driver)
.dragAndDrop(source, target)
.perform();
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
Alert alert = wait.until(
ExpectedConditions.alertIsPresent()
);
System.out.println(alert.getText());
alert.accept();
new Actions(driver)
.dragAndDrop(source, target)
.perform();
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(
ExpectedConditions.urlContains("success")
);
System.out.println(driver.getCurrentUrl());
new Actions(driver)
.dragAndDrop(source, target)
.perform();
Assert.assertTrue(
driver.getCurrentUrl().contains("success"),
"Expected page was not opened"
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
WebElement message = driver.findElement(
By.id("successMessage")
);
Assert.assertEquals(
message.getText(),
"Item moved successfully"
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
WebElement panel = new WebDriverWait(
driver,
Duration.ofSeconds(10)
).until(
ExpectedConditions.visibilityOfElementLocated(
By.id("resultPanel")
)
);
Assert.assertTrue(panel.isDisplayed());
If the source or target is outside the visible viewport, scrolling can help bring the element into view before interaction.
WebElement target = driver.findElement(
By.id("target")
);
((JavascriptExecutor) driver).executeScript(
"arguments[0].scrollIntoView({block:'center'});",
target
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
import org.openqa.selenium.JavascriptExecutor;If the source and target elements exist inside an iframe, Selenium must switch into the iframe before locating and interacting with those elements.
WebElement frame = driver.findElement(
By.id("dragFrame")
);
driver.switchTo().frame(frame);
WebElement source = driver.findElement(
By.id("source")
);
WebElement target = driver.findElement(
By.id("target")
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
driver.switchTo().defaultContent();
driver.switchTo().frame("outerFrame");
driver.switchTo().frame("innerFrame");
WebElement source = driver.findElement(
By.id("source")
);
WebElement target = driver.findElement(
By.id("target")
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
driver.switchTo().defaultContent();
If a drag-and-drop operation causes another browser window or tab to open, switch to the appropriate window before continuing with further validation.
String parent = driver.getWindowHandle();
new Actions(driver)
.dragAndDrop(source, target)
.perform();
for (String handle : driver.getWindowHandles()) {
if (!handle.equals(parent)) {
driver.switchTo().window(handle);
break;
}
}
String parentWindow = driver.getWindowHandle();
new Actions(driver)
.dragAndDrop(source, target)
.perform();
for (String handle : driver.getWindowHandles()) {
if (!handle.equals(parentWindow)) {
driver.switchTo().window(handle);
System.out.println(
driver.getTitle()
);
}
}
Automation frameworks should handle expected Selenium exceptions appropriately and provide useful logs.
try {
WebElement source = driver.findElement(
By.id("source")
);
WebElement target = driver.findElement(
By.id("target")
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
} catch (Exception e) {
System.out.println(
"Drag and drop failed: " + e.getMessage()
);
}
This exception can occur when the source or target element cannot currently be interacted with.
Possible reasons include:
An overlay, popup, tooltip, or another element may interfere with the mouse interaction.
Useful troubleshooting steps include:
A stale element exception can occur when the DOM changes after the source or target was located.
A common solution is to locate the elements again after the DOM update.
WebElement source = wait.until(
ExpectedConditions.refreshed(
ExpectedConditions.elementToBeClickable(
By.id("source")
)
)
);
WebElement target = wait.until(
ExpectedConditions.refreshed(
ExpectedConditions.visibilityOfElementLocated(
By.id("target")
)
)
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
If an element is not visible, check:
A hidden element should not normally be treated as an ordinary user-interaction target. Instead, make the required UI state visible and interact with the actual visible source or target.
A disabled control may not accept a drag-and-drop operation. Selenium should verify the application behavior instead of forcing an artificial interaction.
WebElement target = driver.findElement(
By.id("dropTarget")
);
Assert.assertFalse(
target.isEnabled(),
"Target should be disabled"
);
Stable locators make drag-and-drop tests more reliable.
By.xpath("//div[@data-item='task-1001']")Avoid locators that depend heavily on changing DOM indexes.
//div[3]/div[2]/table/tr[4]/td[2]/divPrefer a meaningful attribute or relationship-based locator.
Consider a task-management application containing a Kanban board. A user drags a task from the To Do column to the In Progress column.
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement task = wait.until(
ExpectedConditions.elementToBeClickable(
By.xpath("//div[@data-task='TASK1001']")
)
);
WebElement inProgress = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("inProgress")
)
);
new Actions(driver)
.dragAndDrop(task, inProgress)
.perform();
WebElement movedTask = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.xpath("//div[@data-task='TASK1001']")
)
);
Assert.assertTrue(
movedTask.isDisplayed(),
"Task was not displayed after drag and drop"
);
An e-commerce application may allow a user to drag a product into a comparison area or shopping cart.
WebElement product = driver.findElement(
By.cssSelector(".product-card")
);
WebElement cart = driver.findElement(
By.id("cart")
);
new Actions(driver)
.dragAndDrop(product, cart)
.perform();
A web-based file manager may allow users to move files between folders using drag and drop.
WebElement file = driver.findElement(
By.cssSelector(".file-item")
);
WebElement folder = driver.findElement(
By.cssSelector(".destination-folder")
);
new Actions(driver)
.dragAndDrop(file, folder)
.perform();
A dashboard may allow users to rearrange widgets by dragging one widget to another location.
WebElement widget = driver.findElement(
By.id("revenueWidget")
);
WebElement targetArea = driver.findElement(
By.id("dashboardDropZone")
);
new Actions(driver)
.dragAndDrop(widget, targetArea)
.perform();
| Test Case ID | Scenario | Expected Result |
|---|---|---|
| TC-DRAGDROP-001 | Drag valid task to target column | Task moves successfully |
| TC-DRAGDROP-002 | Drag product to cart | Product is added to cart |
| TC-DRAGDROP-003 | Drag item to disabled target | Item is not moved |
| TC-DRAGDROP-004 | Drag dynamic element | Element is located after loading and operation succeeds |
Test Case ID: TC-DRAGDROP-001
Title: Verify drag and drop functionality
Precondition: User is logged in
Steps:
1. Navigate to the required page
2. Locate the source element
3. Locate the target element
4. Perform drag and drop
5. Wait for expected result
6. Validate the result
Expected Result:
The source element should be moved to the
specified destination successfully.
try {
WebElement source = driver.findElement(
By.id("source")
);
WebElement target = driver.findElement(
By.id("target")
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
} catch (Exception e) {
File screenshot = ((TakesScreenshot) driver)
.getScreenshotAs(OutputType.FILE);
System.out.println(
"Drag and drop failed: " + e.getMessage()
);
}
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import java.io.File;
Logging helps identify the source, target, and stage at which a drag-and-drop operation failed.
System.out.println(
"Performing drag and drop"
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
System.out.println(
"Drag and drop completed"
);
In a professional framework, drag-and-drop logic should be reusable rather than duplicated across every test.
src
├── main
│ └── java
│ ├── pages
│ ├── utilities
│ ├── waits
│ └── base
└── test
└── java
├── tests
└── testdata
public void dragAndDrop(By sourceLocator, By targetLocator) {
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement source = wait.until(
ExpectedConditions.elementToBeClickable(
sourceLocator
)
);
WebElement target = wait.until(
ExpectedConditions.visibilityOfElementLocated(
targetLocator
)
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
}
dragAndDrop(
By.id("source"),
By.id("target")
);
click() when drag and drop is required.| Aspect | Actions Drag and Drop | JavaScript |
|---|---|---|
| User-like interaction | Yes | Depends on implementation |
| Mouse movement | Supported | Not a direct mouse interaction |
| Preferred for normal UI testing | Yes | Usually fallback |
| Maintainability | Generally better | Depends on use case |
The Actions API represents advanced user interactions and is appropriate when a test needs to simulate mouse behavior such as drag and drop, double click, hover, click and hold, and keyboard combinations.
When automating drag-and-drop functionality, testers should also consider whether the application provides an accessible alternative. Important workflows should not depend exclusively on mouse gestures when an equivalent keyboard or other accessible interaction is available.
Responsive layouts may change element positions and dimensions across viewport sizes. Prefer element-based interaction rather than fixed coordinate-based automation.
WebElement source = driver.findElement(
By.cssSelector(".responsive-source")
);
WebElement target = driver.findElement(
By.cssSelector(".responsive-target")
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
When executing automation across multiple browsers, verify that the application responds consistently to the drag-and-drop interaction.
| Browser | Test |
|---|---|
| Chrome | Drag and drop behavior |
| Firefox | Drag and drop behavior |
| Edge | Drag and drop behavior |
When tests run in parallel, each test should use an isolated driver instance and independent test data wherever required. This prevents one test from changing the source or target state used by another test.
For data-driven tests, the source item and destination can be supplied from test data rather than hard-coded values.
String taskId = "TASK1001";
String targetColumn = "inProgress";
WebElement source = driver.findElement(
By.xpath("//div[@data-task='" + taskId + "']")
);
WebElement target = driver.findElement(
By.id(targetColumn)
);
new Actions(driver)
.dragAndDrop(source, target)
.perform();
| Task ID | Destination | Expected Action |
|---|---|---|
| TASK1001 | In Progress | Task moves successfully |
| TASK1002 | Completed | Task moves successfully |
| TASK1003 | Review | Task moves successfully |
Drag and Drop is an advanced mouse interaction used to move a web element from one location to another. Selenium Java provides the dragAndDrop() method through the Actions class.
Actions actions = new Actions(driver);
actions.dragAndDrop(source, target).perform();
The org.openqa.selenium.interactions.Actions class is commonly used to perform drag-and-drop and other advanced user interactions.
For complex custom components, a manual Actions sequence can be attempted.
new Actions(driver)
.moveToElement(source)
.clickAndHold()
.moveToElement(target)
.release()
.perform();
The perform() method executes the interaction sequence built using the Actions API.
new Actions(driver)
.dragAndDrop(source, target)
.perform();
dragAndDrop(source, target) for standard interactions.clickAndHold(), moveToElement(), and release() for manual control.perform() to execute the action.Project: Kanban Task Drag and Drop Automation
Automate a task-management application where a task can be dragged from the To Do column into the In Progress column.
@Test
public void verifyTaskDragAndDrop() {
WebDriverWait wait =
new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement task = wait.until(
ExpectedConditions.elementToBeClickable(
By.cssSelector("div[data-task='TASK1001']")
)
);
WebElement inProgress = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("inProgress")
)
);
new Actions(driver)
.dragAndDrop(task, inProgress)
.perform();
WebElement movedTask = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.cssSelector("div[data-task='TASK1001']")
)
);
Assert.assertTrue(
movedTask.isDisplayed(),
"Task was not displayed after drag and drop"
);
}
Drag and Drop is an important mouse interaction in Selenium WebDriver automation. Selenium Java provides the Actions class and its dragAndDrop() method to automate interfaces that depend on moving elements from one location to another.
A reliable drag-and-drop test should use stable source and target locators, appropriate waits, correct frame or window handling, reusable framework utilities, and assertions that verify the expected application behavior.
For complex custom interfaces, the manual sequence of clickAndHold(), moveToElement(), and release() can provide greater control than the direct dragAndDrop() method.
Drag-and-drop automation is especially useful for CRM systems, e-commerce applications, Kanban boards, dashboards, file-management interfaces, sortable lists, workflow applications, and other web applications where mouse movement is part of the user workflow.
Recommended Selenium Learning Resources:
