jyapayne/langflow
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

feat: Enhance API request component (#8070)

Browse source 
* update the api request component

* [autofix.ci] apply automated fixes

* update the component

* Update test_api_request_component.py

* [autofix.ci] apply automated fixes

* remove MODE_CONFIG unused variable

* [autofix.ci] apply automated fixes

* use normalize function

* Update template

* Update test_api_request_component.py

* UI test fix

* selector fix

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Yuqi Tang <yuqi.tang@datastax.com>
Co-authored-by: Mike Fortman <michael.fortman@datastax.com>
This commit is contained in:
Edwin Jose 2025-05-22 11:41:19 -04:00 • committed by GitHub
commit ba92fc1e78
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
5 changed files with 256 additions and 351 deletions
Download patch file Download diff file Expand all files Collapse all files

391
src/backend/base/langflow/components/data/api_request.py
View file

@ -1,4 +1,3 @@
import asyncio
import json
import re
import tempfile
@ -14,65 +13,74 @@ import validators
from langflow.base.curl.parse import parse_context
from langflow.custom import Component
from langflow.inputs.inputs import TabInput
from langflow.io import (
BoolInput,
DataInput,
DropdownInput,
FloatInput,
IntInput,
MessageTextInput,
MultilineInput,
Output,
StrInput,
TableInput,
)
from langflow.schema import Data
from langflow.schema.dataframe import DataFrame
from langflow.schema.dotdict import dotdict
from langflow.services.deps import get_settings_service
from langflow.utils.component_utils import set_current_fields, set_field_advanced, set_field_display
# Get settings using the service
# Define fields for each mode
MODE_FIELDS = {
"URL": [
"url_input",
"method",
],
"cURL": ["curl_input"],
}
# Fields that should always be visible
DEFAULT_FIELDS = ["mode"]
class APIRequestComponent(Component):
display_name = "API Request"
description = "Make HTTP requests using URLs or cURL commands."
description = "Make HTTP requests using URL or cURL commands."
icon = "Globe"
name = "APIRequest"
default_keys = ["urls", "method", "query_params"]
inputs = [
MessageTextInput(
name="urls",
display_name="URLs",
list=True,
info="Enter one or more URLs, separated by commas.",
name="url_input",
display_name="URL",
info="Enter the URL for the request.",
advanced=False,
tool_mode=True,
),
MultilineInput(
name="curl",
name="curl_input",
display_name="cURL",
info=(
"Paste a curl command to populate the fields. "
"This will fill in the dictionary fields for headers and body."
),
advanced=True,
real_time_refresh=True,
tool_mode=True,
advanced=True,
show=False,
),
DropdownInput(
name="method",
display_name="Method",
options=["GET", "POST", "PATCH", "PUT", "DELETE"],
value="GET",
info="The HTTP method to use.",
real_time_refresh=True,
),
BoolInput(
name="use_curl",
display_name="Use cURL",
value=False,
TabInput(
name="mode",
display_name="Mode",
options=["URL", "cURL"],
value="URL",
info="Enable cURL mode to populate fields from a cURL command.",
real_time_refresh=True,
),
@ -161,8 +169,7 @@ class APIRequestComponent(Component):
]
outputs = [
Output(display_name="Data", name="data", method="make_requests"),
Output(display_name="DataFrame", name="dataframe", method="as_dataframe"),
Output(display_name="API Response", name="data", method="make_api_requests"),
]
def _parse_json_value(self, value: Any) -> Any:
@ -178,13 +185,7 @@ class APIRequestComponent(Component):
return parsed
def _process_body(self, body: Any) -> dict:
"""Process the body input into a valid dictionary.
Args:
body: The body to process, can be dict, str, or list
Returns:
Processed dictionary
"""
"""Process the body input into a valid dictionary."""
if body is None:
return {}
if isinstance(body, dict):
@ -193,7 +194,6 @@ class APIRequestComponent(Component):
return self._process_string_body(body)
if isinstance(body, list):
return self._process_list_body(body)
return {}
def _process_dict_body(self, body: dict) -> dict:
@ -210,20 +210,16 @@ class APIRequestComponent(Component):
def _process_list_body(self, body: list) -> dict:
"""Process list body by converting to key-value dictionary."""
processed_dict = {}
try:
for item in body:
if not self._is_valid_key_value_item(item):
continue
key = item["key"]
value = self._parse_json_value(item["value"])
processed_dict[key] = value
except (KeyError, TypeError, ValueError) as e:
self.log(f"Failed to process body list: {e}")
return {} # Return empty dictionary instead of None
return {}
return processed_dict
def _is_valid_key_value_item(self, item: Any) -> bool:
@ -231,30 +227,22 @@ class APIRequestComponent(Component):
return isinstance(item, dict) and "key" in item and "value" in item
def parse_curl(self, curl: str, build_config: dotdict) -> dotdict:
"""Parse a cURL command and update build configuration.
Args:
curl: The cURL command to parse
build_config: The build configuration to update
Returns:
Updated build configuration
"""
"""Parse a cURL command and update build configuration."""
try:
parsed = parse_context(curl)
# Update basic configuration
build_config["urls"]["value"] = [parsed.url]
url = parsed.url
# Normalize URL before setting it
url = self._normalize_url(url)
build_config["url_input"]["value"] = url
build_config["method"]["value"] = parsed.method.upper()
build_config["headers"]["advanced"] = True
build_config["body"]["advanced"] = True
# Process headers
headers_list = [{"key": k, "value": v} for k, v in parsed.headers.items()]
build_config["headers"]["value"] = headers_list
if headers_list:
build_config["headers"]["advanced"] = False
# Process body data
if not parsed.data:
build_config["body"]["value"] = []
@ -267,13 +255,10 @@ class APIRequestComponent(Component):
for k, v in json_data.items()
]
build_config["body"]["value"] = body_list
build_config["body"]["advanced"] = False
else:
build_config["body"]["value"] = [{"key": "data", "value": json.dumps(json_data)}]
build_config["body"]["advanced"] = False
except json.JSONDecodeError:
build_config["body"]["value"] = [{"key": "data", "value": parsed.data}]
build_config["body"]["advanced"] = False
except Exception as exc:
msg = f"Error parsing curl: {exc}"
@ -282,106 +267,16 @@ class APIRequestComponent(Component):
return build_config
def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
if field_name == "use_curl" and field_value:
# if we remove field value from validation, this gets validated every time
build_config = self._update_curl_mode(build_config, use_curl=field_value)
def _normalize_url(self, url: str) -> str:
"""Normalize URL by adding https:// if no protocol is specified."""
if not url or not isinstance(url, str):
msg = "URL cannot be empty"
raise ValueError(msg)
# If curl is not used, we don't need to reset the fields
if not self.use_curl:
return build_config
# Fields that should not be reset
preserve_fields = {"timeout", "follow_redirects", "save_to_file", "include_httpx_metadata", "use_curl"}
# Mapping between input types and their reset values
type_reset_mapping = {
TableInput: [],
BoolInput: False,
IntInput: 0,
FloatInput: 0.0,
MessageTextInput: "",
StrInput: "",
MultilineInput: "",
DropdownInput: "GET",
DataInput: {},
}
for input_field in self.inputs:
# Only reset if field is not in preserve list
if input_field.name not in preserve_fields:
reset_value = type_reset_mapping.get(type(input_field), None)
build_config[input_field.name]["value"] = reset_value
self.log(f"Reset field {input_field.name} to {reset_value}")
# Don't try to parse the boolean value as a curl command
return build_config
if field_name == "method" and not self.use_curl:
build_config = self._update_method_fields(build_config, field_value)
elif field_name == "curl" and self.use_curl and field_value:
# Not reachable, because we don't have a way to update
# the curl field, self.use_curl is set after the build_config is created
build_config = self.parse_curl(field_value, build_config)
return build_config
def _update_curl_mode(self, build_config: dotdict, *, use_curl: bool) -> dotdict:
always_visible = ["method", "use_curl"]
for field in self.inputs:
field_name = field.name
field_config = build_config.get(field_name)
if isinstance(field_config, dict):
if field_name in always_visible:
field_config["advanced"] = False
elif field_name == "urls":
field_config["advanced"] = use_curl
elif field_name == "curl":
field_config["advanced"] = not use_curl
field_config["real_time_refresh"] = use_curl
elif field_name in {"body", "headers"}:
field_config["advanced"] = True # Always keep body and headers in advanced when use_curl is False
else:
field_config["advanced"] = use_curl or field_config.get("advanced")
else:
self.log(f"Expected dict for build_config[{field_name}], got {type(field_config).__name__}")
if not use_curl:
current_method = build_config.get("method", {}).get("value", "GET")
build_config = self._update_method_fields(build_config, current_method)
return build_config
def _update_method_fields(self, build_config: dotdict, method: str) -> dotdict:
common_fields = [
"urls",
"method",
"use_curl",
]
always_advanced_fields = [
"body",
"headers",
"timeout",
"follow_redirects",
"save_to_file",
"include_httpx_metadata",
]
body_fields = ["body"]
for field in self.inputs:
field_name = field.name
field_config = build_config.get(field_name)
if isinstance(field_config, dict):
if field_name in common_fields:
field_config["advanced"] = False
elif field_name in body_fields:
field_config["advanced"] = method not in {"POST", "PUT", "PATCH"}
elif field_name in always_advanced_fields:
field_config["advanced"] = True
else:
self.log(f"Expected dict for build_config[{field_name}], got {type(field_config).__name__}")
return build_config
url = url.strip()
if url.startswith(("http://", "https://")):
return url
return f"https://{url}"
async def make_request(
self,
@ -401,19 +296,20 @@ class APIRequestComponent(Component):
msg = f"Unsupported method: {method}"
raise ValueError(msg)
# Process body using the new helper method
processed_body = self._process_body(body)
redirection_history = []
try:
response = await client.request(
method,
url,
headers=headers,
json=processed_body,
timeout=timeout,
follow_redirects=follow_redirects,
)
# Prepare request parameters
request_params = {
"method": method,
"url": url,
"headers": headers,
"json": processed_body,
"timeout": timeout,
"follow_redirects": follow_redirects,
}
response = await client.request(**request_params)
redirection_history = [
{
@ -426,15 +322,20 @@ class APIRequestComponent(Component):
is_binary, file_path = await self._response_info(response, with_file_path=save_to_file)
response_headers = self._headers_to_dict(response.headers)
metadata: dict[str, Any] = {
# Base metadata
metadata = {
"source": url,
"status_code": response.status_code,
"response_headers": response_headers,
}
if redirection_history:
metadata["redirection_history"] = redirection_history
if save_to_file:
mode = "wb" if is_binary else "w"
encoding = response.encoding if mode == "w" else None
if file_path:
# Ensure parent directory exists
await aiofiles_os.makedirs(file_path.parent, exist_ok=True)
if is_binary:
async with aiofiles.open(file_path, "wb") as f:
@ -447,16 +348,10 @@ class APIRequestComponent(Component):
metadata["file_path"] = str(file_path)
if include_httpx_metadata:
metadata.update(
{
"headers": headers,
"status_code": response.status_code,
"response_headers": response_headers,
**({"redirection_history": redirection_history} if redirection_history else {}),
}
)
metadata.update({"headers": headers})
return Data(data=metadata)
# Handle response content
if is_binary:
result = response.content
else:
@ -466,28 +361,13 @@ class APIRequestComponent(Component):
self.log("Failed to decode JSON response")
result = response.text.encode("utf-8")
metadata.update({"result": result})
metadata["result"] = result
if include_httpx_metadata:
metadata.update(
{
"headers": headers,
"status_code": response.status_code,
"response_headers": response_headers,
**({"redirection_history": redirection_history} if redirection_history else {}),
}
)
metadata.update({"headers": headers})
return Data(data=metadata)
except httpx.TimeoutException:
return Data(
data={
"source": url,
"headers": headers,
"status_code": 408,
"error": "Request timed out",
},
)
except Exception as exc: # noqa: BLE001
except (httpx.HTTPError, httpx.RequestError, httpx.TimeoutException) as exc:
self.log(f"Error making request to {url}")
return Data(
data={
@ -500,15 +380,33 @@ class APIRequestComponent(Component):
)
def add_query_params(self, url: str, params: dict) -> str:
"""Add query parameters to URL efficiently."""
if not params:
return url
url_parts = list(urlparse(url))
query = dict(parse_qsl(url_parts[4]))
query.update(params)
url_parts[4] = urlencode(query)
return urlunparse(url_parts)
async def make_requests(self) -> list[Data]:
def _headers_to_dict(self, headers: httpx.Headers) -> dict[str, str]:
"""Convert HTTP headers to a dictionary with lowercased keys."""
return {k.lower(): v for k, v in headers.items()}
def _process_headers(self, headers: Any) -> dict:
"""Process the headers input into a valid dictionary."""
if headers is None:
return {}
if isinstance(headers, dict):
return headers
if isinstance(headers, list):
return {item["key"]: item["value"] for item in headers if self._is_valid_key_value_item(item)}
return {}
async def make_api_requests(self) -> Data:
"""Make HTTP request with optimized parameter handling."""
method = self.method
urls = [url.strip() for url in self.urls if url.strip()]
url = self.url_input.strip() if isinstance(self.url_input, str) else ""
headers = self.headers or {}
body = self.body or {}
timeout = self.timeout
@ -516,48 +414,65 @@ class APIRequestComponent(Component):
save_to_file = self.save_to_file
include_httpx_metadata = self.include_httpx_metadata
if self.use_curl and self.curl:
self._build_config = self.parse_curl(self.curl, dotdict())
# if self.mode == "cURL" and self.curl_input:
# self._build_config = self.parse_curl(self.curl_input, dotdict())
# # After parsing curl, get the normalized URL
# url = self._build_config["url_input"]["value"]
invalid_urls = [url for url in urls if not validators.url(url)]
if invalid_urls:
msg = f"Invalid URLs provided: {invalid_urls}"
# Normalize URL before validation
url = self._normalize_url(url)
# Validate URL
if not validators.url(url):
msg = f"Invalid URL provided: {url}"
raise ValueError(msg)
# Process query parameters
if isinstance(self.query_params, str):
query_params = dict(parse_qsl(self.query_params))
else:
query_params = self.query_params.data if self.query_params else {}
# Process headers here
# Process headers and body
headers = self._process_headers(headers)
# Process body
body = self._process_body(body)
bodies = [body] * len(urls)
urls = [self.add_query_params(url, query_params) for url in urls]
url = self.add_query_params(url, query_params)
async with httpx.AsyncClient() as client:
results = await asyncio.gather(
*[
self.make_request(
client,
method,
u,
headers,
rec,
timeout,
follow_redirects=follow_redirects,
save_to_file=save_to_file,
include_httpx_metadata=include_httpx_metadata,
)
for u, rec in zip(urls, bodies, strict=False)
]
result = await self.make_request(
client,
method,
url,
headers,
body,
timeout,
follow_redirects=follow_redirects,
save_to_file=save_to_file,
include_httpx_metadata=include_httpx_metadata,
)
self.status = results
return results
self.status = result
return result
def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
"""Update the build config based on the selected mode."""
if field_name != "mode":
return build_config
# print(f"Current mode: {field_value}")
if field_value == "cURL":
set_field_display(build_config, "curl_input", value=True)
build_config = self.parse_curl(self.curl_input, build_config)
else:
set_field_display(build_config, "curl_input", value=False)
return set_current_fields(
build_config=build_config,
action_fields=MODE_FIELDS,
selected_action=field_value,
default_fields=DEFAULT_FIELDS,
func=set_field_advanced,
default_value=True,
)
async def _response_info(
self, response: httpx.Response, *, with_file_path: bool = False
@ -624,43 +539,3 @@ class APIRequestComponent(Component):
file_path = component_temp_dir / f"{timestamp}-{filename}"
return is_binary, file_path
def _headers_to_dict(self, headers: httpx.Headers) -> dict[str, str]:
"""Convert HTTP headers to a dictionary with lowercased keys."""
return {k.lower(): v for k, v in headers.items()}
def _process_headers(self, headers: Any) -> dict:
"""Process the headers input into a valid dictionary.
Args:
headers: The headers to process, can be dict, str, or list
Returns:
Processed dictionary
"""
if headers is None:
return {}
if isinstance(headers, dict):
return headers
if isinstance(headers, list):
processed_headers = {}
try:
for item in headers:
if not self._is_valid_key_value_item(item):
continue
key = item["key"]
value = item["value"]
processed_headers[key] = value
except (KeyError, TypeError, ValueError) as e:
self.log(f"Failed to process headers list: {e}")
return {} # Return empty dictionary instead of None
return processed_headers
return {}
async def as_dataframe(self) -> DataFrame:
"""Convert the API response data into a DataFrame.
Returns:
DataFrame: A DataFrame containing the API response data.
"""
data = await self.make_requests()
return DataFrame(data)

60
src/backend/base/langflow/initial_setup/starter_projects/Pokédex Agent.json
View file

File diff suppressed because one or more lines are too long

136
src/backend/tests/unit/components/data/test_api_request_component.py
View file

@ -1,5 +1,4 @@
from pathlib import Path
from unittest.mock import patch
import aiofiles
import aiofiles.os
@ -8,7 +7,8 @@ import pytest
import respx
from httpx import Response
from langflow.components.data import APIRequestComponent
from langflow.schema import Data, DataFrame
from langflow.schema import Data
from langflow.schema.dotdict import dotdict
from tests.base import ComponentTestBaseWithoutClient
@ -23,16 +23,17 @@ class TestAPIRequestComponent(ComponentTestBaseWithoutClient):
def default_kwargs(self):
"""Return the default kwargs for the component."""
return {
"urls": ["https://example.com/api/test"],
"url_input": "https://example.com/api/test",
"method": "GET",
"headers": [],
"headers": [{"key": "User-Agent", "value": "test-agent"}],
"body": [],
"timeout": 5,
"timeout": 30,
"follow_redirects": True,
"save_to_file": False,
"include_httpx_metadata": False,
"use_curl": False,
"curl": "",
"mode": "URL",
"curl_input": "",
"query_params": {},
}
@pytest.fixture
@ -50,16 +51,18 @@ class TestAPIRequestComponent(ComponentTestBaseWithoutClient):
curl_cmd = (
"curl -X GET https://example.com/api/test -H 'Content-Type: application/json' -d '{\"key\": \"value\"}'"
)
build_config = {
"method": {"value": ""},
"urls": {"value": []},
"headers": {},
"body": {},
}
build_config = dotdict(
{
"method": {"value": ""},
"url_input": {"value": ""},
"headers": {"value": []},
"body": {"value": []},
}
)
new_build_config = component.parse_curl(curl_cmd, build_config.copy())
assert new_build_config["method"]["value"] == "GET"
assert new_build_config["urls"]["value"] == ["https://example.com/api/test"]
assert new_build_config["url_input"]["value"] == "https://example.com/api/test"
assert new_build_config["headers"]["value"] == [{"key": "Content-Type", "value": "application/json"}]
assert new_build_config["body"]["value"] == [{"key": "key", "value": "value"}]
@ -78,7 +81,6 @@ class TestAPIRequestComponent(ComponentTestBaseWithoutClient):
assert isinstance(result, Data)
assert result.data["source"] == url
# The JSON response is nested in the 'result' key
assert "result" in result.data
assert result.data["result"]["key"] == "value"
@ -145,6 +147,7 @@ class TestAPIRequestComponent(ComponentTestBaseWithoutClient):
assert isinstance(result, Data)
assert result.data["source"] == url
assert result.data["result"] == binary_content
@respx.mock
async def test_make_request_timeout(self, component):
@ -160,8 +163,8 @@ class TestAPIRequestComponent(ComponentTestBaseWithoutClient):
)
assert isinstance(result, Data)
assert result.data["status_code"] == 408
assert result.data["error"] == "Request timed out"
assert result.data["status_code"] == 500
assert "Request timed out" in result.data["error"]
@respx.mock
async def test_make_request_with_redirects(self, component):
@ -235,55 +238,55 @@ class TestAPIRequestComponent(ComponentTestBaseWithoutClient):
assert "param1=value1" in result
assert "param2=value2" in result
async def test_output_formats(self, component):
# Test different output formats
with patch.object(component, "make_requests") as mock_make_requests:
mock_make_requests.return_value = [Data(data={"key": "value"})]
async def test_make_api_requests(self, component):
# Test making API requests
url = "https://example.com/api/test"
response_data = {"key": "value"}
# Test DataFrame output
df_result = await component.as_dataframe()
assert isinstance(df_result, DataFrame)
with respx.mock:
respx.get(url).mock(return_value=Response(200, json=response_data))
# Test Data output - to_data returns a list of Data objects
test_data = {"test": "value"}
data_result = component.to_data(test_data)
assert isinstance(data_result, list)
assert all(isinstance(item, Data) for item in data_result)
result = await component.make_api_requests()
assert isinstance(result, Data)
assert result.data["source"] == url
assert result.data["result"]["key"] == "value"
async def test_invalid_urls(self, component):
# Test invalid URL handling
component.urls = ["not_a_valid_url"]
with pytest.raises(ValueError, match="Invalid URLs provided"):
await component.make_requests()
component.url_input = "not_a_valid_url"
with pytest.raises(ValueError, match="Invalid URL provided"):
await component.make_api_requests()
async def test_update_build_config(self, component):
# Test build config updates
build_config = {
"method": {"value": "GET", "advanced": False},
"urls": {"value": [], "advanced": False},
"headers": {"value": [], "advanced": True},
"body": {"value": [], "advanced": True},
"use_curl": {"value": False, "advanced": False},
"curl": {"value": "", "advanced": True},
"timeout": {"value": 5, "advanced": True},
"follow_redirects": {"value": True, "advanced": True},
"save_to_file": {"value": False, "advanced": True},
"include_httpx_metadata": {"value": False, "advanced": True},
"query_params": {"value": {}, "advanced": True},
}
# Test curl mode update
updated = component.update_build_config(
build_config=build_config.copy(), field_value=True, field_name="use_curl"
build_config = dotdict(
{
"method": {"value": "GET", "advanced": False},
"url_input": {"value": "", "advanced": False},
"headers": {"value": [], "advanced": True},
"body": {"value": [], "advanced": True},
"mode": {"value": "URL", "advanced": False},
"curl_input": {"value": "curl -X GET https://example.com/api/test", "advanced": True},
"timeout": {"value": 30, "advanced": True},
"follow_redirects": {"value": True, "advanced": True},
"save_to_file": {"value": False, "advanced": True},
"include_httpx_metadata": {"value": False, "advanced": True},
"query_params": {"value": {}, "advanced": True},
}
)
assert updated["curl"]["advanced"] is False
assert updated["urls"]["advanced"] is True
# Test method update
updated = component.update_build_config(
build_config=build_config.copy(), field_value="POST", field_name="method"
)
assert updated["body"]["advanced"] is False
# Test URL mode
updated = component.update_build_config(build_config=build_config.copy(), field_value="URL", field_name="mode")
assert updated["curl_input"]["advanced"] is True
assert updated["url_input"]["advanced"] is False
# Set the component's curl_input attribute to match the build_config before switching to cURL mode
component.curl_input = build_config["curl_input"]["value"]
# Test cURL mode
updated = component.update_build_config(build_config=build_config.copy(), field_value="cURL", field_name="mode")
assert updated["curl_input"]["advanced"] is False
assert updated["url_input"]["advanced"] is True
@respx.mock
async def test_error_handling(self, component):
@ -307,3 +310,24 @@ class TestAPIRequestComponent(ComponentTestBaseWithoutClient):
method="INVALID",
url=url,
)
async def test_response_info(self, component):
# Test response info handling
url = "https://example.com/api/test"
request = httpx.Request("GET", url)
response = Response(200, text="test content", request=request)
is_binary, file_path = await component._response_info(response, with_file_path=True)
assert not is_binary
assert file_path is not None
assert file_path.suffix == ".txt"
# Test binary response
binary_response = Response(
200, content=b"binary content", headers={"Content-Type": "application/octet-stream"}, request=request
)
is_binary, file_path = await component._response_info(binary_response, with_file_path=True)
assert is_binary
assert file_path is not None
assert file_path.suffix == ".bin"

4
src/frontend/tests/core/features/filterSidebar.spec.ts
View file

@ -32,12 +32,12 @@ test(
await adjustScreenView(page);
await page.waitForSelector(
'[data-testid="handle-apirequest-shownode-urls-left"]',
'[data-testid="handle-apirequest-shownode-url-left"]',
{
timeout: 3000,
},
);
await page.getByTestId("handle-apirequest-shownode-urls-left").click();
await page.getByTestId("handle-apirequest-shownode-url-left").click();
await page.waitForTimeout(500);

16
src/frontend/tests/extended/features/edit-tools.spec.ts
View file

@ -9,17 +9,17 @@ test(
await page.getByTestId("blank-flow").click();
await page.getByTestId("sidebar-search-input").click();
await page.getByTestId("sidebar-search-input").fill("api request");
await page.getByTestId("sidebar-search-input").fill("url");
await page.waitForSelector('[data-testid="dataAPI Request"]', {
await page.waitForSelector('[data-testid="dataURL"]', {
timeout: 3000,
});
await page
.getByTestId("dataAPI Request")
.getByTestId("dataURL")
.hover()
.then(async () => {
await page.getByTestId("add-component-button-api-request").click();
await page.getByTestId("add-component-button-url").click();
});
await page.waitForSelector(
@ -44,7 +44,7 @@ test(
await page.getByTestId("button_open_actions").click();
await page.waitForSelector("text=API Request", { timeout: 30000 });
await page.waitForSelector("text=URL", { timeout: 30000 });
const rowsCount = await page.getByRole("gridcell").count();
@ -200,7 +200,11 @@ test(
await page.getByText("Close").last().click();
expect(
await page.locator('[data-testid="tool_make_requests"]').isVisible(),
await page.locator('[data-testid="tool_fetch_content"]').isVisible(),
).toBe(true);
expect(
await page.locator('[data-testid="tool_as_dataframe"]').isVisible(),
).toBe(true);
},
);