+
+
+
+
-
-
@@ -138,15 +140,60 @@
Interpretation Types
for (const [k,v] of Object.entries(params)) if (v) u.set(k, v);
return u.toString();
}
+ // Source color mapping
+ const sourceColors = {
+ 'labels': '#e15759', // Red - defined but not instantiated
+ 'neo4j': '#59a14f', // Green - from Neo4j
+ 'graph': '#4e79a7', // Blue - in-memory (current default)
+ 'neo4j+labels': '#f28e2c', // Orange - Neo4j + Labels
+ 'graph+labels': '#af7aa1', // Purple - Graph + Labels
+ 'graph+neo4j': '#76b7b2', // Teal - Graph + Neo4j
+ 'all': '#edc949' // Yellow - All three sources
+ };
async function fetchSchema(params) {
try {
- const q = params ? ('?' + qs(params)) : '';
- const url = params ? ('/api/graph/subschema' + q) : '/api/graph/schema';
+ const source = document.getElementById('schema-source')?.value || 'all';
+ params = params || {};
+ params.source = source;
+
+ const q = qs(params);
+ const url = '/api/graph/schema/combined' + (q ? '?' + q : '');
const res = await fetch(url);
return await res.json();
} catch (e) {
console.error('Schema fetch failed', e);
- return { nodes: [], edges: [] };
+ return { nodes: [], edges: [], sources: {} };
+ }
+ }
+ // Update filter dropdowns dynamically based on schema
+ function updateFilters(schema) {
+ const labelSelect = document.getElementById('filter-labels');
+ const relSelect = document.getElementById('filter-reltypes');
+
+ if (labelSelect) {
+ // Preserve current selection
+ const currentLabel = labelSelect.value;
+ // Get unique labels from schema
+ const labels = [...new Set(schema.nodes?.map(n => n.label) || [])].sort();
+ labelSelect.innerHTML = '' +
+ labels.map(l => ``).join('');
+ // Restore selection if still valid
+ if (currentLabel && labels.includes(currentLabel)) {
+ labelSelect.value = currentLabel;
+ }
+ }
+
+ if (relSelect) {
+ // Preserve current selection
+ const currentRel = relSelect.value;
+ // Get unique relationship types from schema
+ const rels = [...new Set(schema.edges?.map(e => e.rel_type) || [])].sort();
+ relSelect.innerHTML = '' +
+ rels.map(r => ``).join('');
+ // Restore selection if still valid
+ if (currentRel && rels.includes(currentRel)) {
+ relSelect.value = currentRel;
+ }
}
}
let nodeMul = 1.0;
@@ -158,29 +205,58 @@ Interpretation Types
function toElements(data){
const nodes = new Map();
for (const n of (data.nodes||[])) {
- nodes.set(n.label, { data: { id: n.label, label: n.label, count: n.count } });
+ nodes.set(n.label, {
+ data: {
+ id: n.label,
+ label: n.label,
+ count: n.count,
+ source: n.source || 'graph'
+ }
+ });
}
const edges = [];
for (const e of (data.edges||[])) {
const id = `${e.start_label}|${e.rel_type}|${e.end_label}`;
- if (!nodes.has(e.start_label)) nodes.set(e.start_label, { data: { id: e.start_label, label: e.start_label, count: 1 } });
- if (!nodes.has(e.end_label)) nodes.set(e.end_label, { data: { id: e.end_label, label: e.end_label, count: 1 } });
- edges.push({ data: { id, source: e.start_label, target: e.end_label, type: e.rel_type, count: e.count } });
+ if (!nodes.has(e.start_label)) {
+ nodes.set(e.start_label, {
+ data: { id: e.start_label, label: e.start_label, count: 1, source: e.source || 'graph' }
+ });
+ }
+ if (!nodes.has(e.end_label)) {
+ nodes.set(e.end_label, {
+ data: { id: e.end_label, label: e.end_label, count: 1, source: e.source || 'graph' }
+ });
+ }
+ edges.push({
+ data: {
+ id,
+ source: e.start_label,
+ target: e.end_label,
+ type: e.rel_type,
+ count: e.count,
+ edgeSource: e.source || 'graph'
+ }
+ });
}
return [...nodes.values(), ...edges];
}
let data = await fetchSchema();
+ updateFilters(data); // Initialize filter dropdowns
const cy = cytoscape({
container: document.getElementById('schema-graph'),
elements: toElements(data),
style: [
{ selector: 'node', style: {
'label': 'data(label)', 'text-valign': 'center', 'text-halign': 'center',
- 'background-color': '#4e79a7', 'color': '#fff', 'font-size': 10,
+ 'background-color': ele => sourceColors[ele.data('source')] || sourceColors['graph'],
+ 'color': '#fff', 'font-size': 10,
'width': ele => scale(ele.data('count')), 'height': ele => scale(ele.data('count'))
}},
{ selector: 'edge', style: {
- 'curve-style': 'bezier', 'line-color': '#999', 'target-arrow-color': '#999', 'target-arrow-shape': 'triangle',
+ 'curve-style': 'bezier',
+ 'line-color': ele => sourceColors[ele.data('edgeSource')] || '#999',
+ 'target-arrow-color': ele => sourceColors[ele.data('edgeSource')] || '#999',
+ 'target-arrow-shape': 'triangle',
'width': ele => Math.max(1, Math.log(1 + (ele.data('count')||1))) * edgeMul,
'label': 'data(type)', 'font-size': () => labelFont, 'color': '#555', 'text-rotation': 'autorotate', 'text-margin-x': 2, 'text-margin-y': 2, 'text-outline-color': () => (highContrast ? '#fff' : 'transparent'), 'text-outline-width': () => (highContrast ? 3 : 0)
}}
@@ -193,10 +269,12 @@ Interpretation Types
}
function render(newData){
data = newData;
+ updateFilters(data); // Update filter dropdowns with new schema
cy.json({ elements: toElements(data) });
const mode = (document.getElementById('layout-mode')||{}).value || 'cose';
runLayout(mode);
}
+ const sourceSel = document.getElementById('schema-source');
const lbl = document.getElementById('filter-labels');
const rlt = document.getElementById('filter-reltypes');
const layoutSel = document.getElementById('layout-mode');
@@ -222,12 +300,42 @@ Interpretation Types
async function onFilter(){
const labels = lbl && lbl.value ? lbl.value : '';
const rel_types = rlt && rlt.value ? rlt.value : '';
- const params = {};
- if (labels) params.labels = labels;
- if (rel_types) params.rel_types = rel_types;
- const nd = await fetchSchema(Object.keys(params).length ? params : null);
+
+ // For combined schema endpoint, we filter on client-side for now
+ // (server-side filtering can be added later if needed)
+ const fullData = await fetchSchema();
+
+ let filteredNodes = fullData.nodes || [];
+ let filteredEdges = fullData.edges || [];
+
+ if (labels) {
+ // Filter nodes by label
+ filteredNodes = filteredNodes.filter(n => n.label === labels);
+ // Filter edges that connect to this label
+ filteredEdges = filteredEdges.filter(e =>
+ e.start_label === labels || e.end_label === labels
+ );
+ }
+
+ if (rel_types) {
+ // Filter edges by relationship type
+ filteredEdges = filteredEdges.filter(e => e.rel_type === rel_types);
+ }
+
+ const filteredData = {
+ nodes: filteredNodes,
+ edges: filteredEdges,
+ sources: fullData.sources
+ };
+
+ render(filteredData);
+ }
+ async function onSourceChange(){
+ // When source changes, reload full schema
+ const nd = await fetchSchema();
render(nd);
}
+ if (sourceSel) sourceSel.onchange = onSourceChange;
if (lbl) lbl.onchange = onFilter;
if (rlt) rlt.onchange = onFilter;
if (layoutSel) layoutSel.onchange = () => runLayout(layoutSel.value);
diff --git a/scidk/web/routes/api_admin.py b/scidk/web/routes/api_admin.py
index 917fccb..3c04f69 100644
--- a/scidk/web/routes/api_admin.py
+++ b/scidk/web/routes/api_admin.py
@@ -290,3 +290,80 @@ def api_admin_cleanup_test_scans():
except Exception as e:
return jsonify({'error': str(e)}), 500
+
+@bp.post('/admin/cleanup-test-labels')
+def api_admin_cleanup_test_labels():
+ """Remove test labels from the database (labels with test prefixes like E2E*, Test*, etc).
+
+ This endpoint cleans up labels created during testing that accumulate over time.
+
+ Returns:
+ JSON with counts of deleted labels
+ """
+ try:
+ from ...core import path_index_sqlite as pix
+
+ # Test label patterns to delete
+ test_patterns = [
+ 'E2E%', # E2E test labels
+ 'Test%', # TestLabel, TestNode, etc
+ 'Person%', # From arrows test
+ 'Company%', # From arrows test
+ 'Project%', # Multiple test uses
+ 'Export%', # ExportProject, ExportTask
+ 'Layout%', # LayoutTestLabel
+ 'Roundtrip%', # RoundtripAuthor, RoundtripBook
+ 'Label%', # Label1, Label2, Label3
+ 'AllTypes%', # AllTypes
+ 'File%', # File from relationship tests
+ 'Directory%', # Directory from relationship tests
+ 'User%', # User from relationship tests
+ 'Update%', # UpdateTest
+ 'Delete%', # DeleteTest
+ 'Bad%', # BadLabel
+ 'Node%', # TestNode, OtherNode, NodeA, NodeB
+ ]
+
+ conn = pix.connect()
+ try:
+ cur = conn.cursor()
+
+ # Check if label_definitions table exists
+ cur.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='label_definitions'")
+ if not cur.fetchone():
+ return jsonify({
+ 'deleted_labels': 0,
+ 'message': 'Label definitions table does not exist'
+ }), 200
+
+ # Collect label names that match test patterns
+ deleted_labels = []
+ total_deleted = 0
+
+ for pattern in test_patterns:
+ cur.execute("SELECT name FROM label_definitions WHERE name LIKE ?", (pattern,))
+ matching_labels = [row[0] for row in cur.fetchall()]
+ deleted_labels.extend(matching_labels)
+
+ # Delete matching labels
+ cur.execute("DELETE FROM label_definitions WHERE name LIKE ?", (pattern,))
+ total_deleted += cur.rowcount
+
+ conn.commit()
+
+ return jsonify({
+ 'deleted_labels': total_deleted,
+ 'label_names': deleted_labels[:10] + (['...'] if len(deleted_labels) > 10 else []),
+ 'total_test_labels_found': len(deleted_labels),
+ 'message': f'Successfully deleted {total_deleted} test labels'
+ }), 200
+
+ finally:
+ try:
+ conn.close()
+ except Exception:
+ pass
+
+ except Exception as e:
+ return jsonify({'error': str(e)}), 500
+
diff --git a/scidk/web/routes/api_graph.py b/scidk/web/routes/api_graph.py
index 6f2e3bf..358b572 100644
--- a/scidk/web/routes/api_graph.py
+++ b/scidk/web/routes/api_graph.py
@@ -24,6 +24,214 @@ def api_graph_schema():
return jsonify(data), 200
+@bp.get('/graph/schema/combined')
+def api_graph_schema_combined():
+ """
+ Unified schema endpoint combining local Labels, Neo4j schema, and in-memory graph.
+
+ Query params:
+ - source: 'labels' | 'neo4j' | 'graph' | 'all' (default: 'all')
+ - include_properties: 'true' | 'false' (default: 'false')
+
+ Returns:
+ {
+ "nodes": [{"label": "...", "count": 0, "source": "labels", "properties": [...]}],
+ "edges": [{"start_label": "...", "rel_type": "...", "end_label": "...", "count": 0, "source": "labels"}],
+ "sources": {"labels": {"count": N, "enabled": true}, ...}
+ }
+ """
+ source = (request.args.get('source') or 'all').strip().lower()
+ include_props = (request.args.get('include_properties') or 'false').strip().lower() == 'true'
+
+ result = {'nodes': [], 'edges': [], 'sources': {}}
+
+ # Track unique nodes/edges to avoid duplicates (key by label/triple)
+ seen_nodes = {}
+ seen_edges = {}
+
+ # 1. Get local Labels definitions
+ if source in ('labels', 'all'):
+ try:
+ from ...services.label_service import LabelService
+ label_service = LabelService(current_app)
+ labels = label_service.list_labels()
+
+ for label in labels:
+ label_name = label.get('name')
+ if label_name and label_name not in seen_nodes:
+ node = {
+ 'label': label_name,
+ 'count': 0, # No instances yet (definition only)
+ 'source': 'labels'
+ }
+ if include_props:
+ node['properties'] = label.get('properties', [])
+ result['nodes'].append(node)
+ seen_nodes[label_name] = 'labels'
+
+ # Add relationships
+ for rel in label.get('relationships', []):
+ edge_key = (label_name, rel.get('type'), rel.get('target_label'))
+ if edge_key not in seen_edges:
+ result['edges'].append({
+ 'start_label': label_name,
+ 'rel_type': rel.get('type'),
+ 'end_label': rel.get('target_label'),
+ 'count': 0,
+ 'source': 'labels'
+ })
+ seen_edges[edge_key] = 'labels'
+
+ result['sources']['labels'] = {'count': len(labels), 'enabled': True}
+ except Exception as e:
+ result['sources']['labels'] = {'count': 0, 'enabled': False, 'error': str(e)}
+
+ # 2. Get Neo4j schema (if connected and requested)
+ if source in ('neo4j', 'all'):
+ try:
+ uri, user, pwd, database, auth_mode = get_neo4j_params()
+ if uri:
+ from neo4j import GraphDatabase
+ driver = None
+ try:
+ driver = GraphDatabase.driver(uri, auth=None if auth_mode == 'none' else (user, pwd))
+ with driver.session(database=database) as sess:
+ # Get node label counts
+ q_nodes = "MATCH (n) WITH head(labels(n)) AS l, count(*) AS c RETURN l AS label, c ORDER BY c DESC"
+ neo4j_nodes = [dict(record) for record in sess.run(q_nodes)]
+
+ # Get relationship triples counts
+ q_edges = (
+ "MATCH (s)-[r]->(t) "
+ "WITH head(labels(s)) AS sl, type(r) AS rt, head(labels(t)) AS tl, count(*) AS c "
+ "RETURN sl AS start_label, rt AS rel_type, tl AS end_label, c ORDER BY c DESC"
+ )
+ neo4j_edges = [dict(record) for record in sess.run(q_edges)]
+
+ # Add nodes from Neo4j (prefer Neo4j counts if already seen from labels)
+ for n in neo4j_nodes:
+ label_name = n.get('label')
+ if label_name:
+ if label_name in seen_nodes:
+ # Update existing node with Neo4j count
+ for node in result['nodes']:
+ if node['label'] == label_name:
+ node['count'] = n.get('c', 0)
+ node['source'] = 'neo4j+labels' if node['source'] == 'labels' else 'neo4j'
+ break
+ seen_nodes[label_name] = 'neo4j'
+ else:
+ result['nodes'].append({
+ 'label': label_name,
+ 'count': n.get('c', 0),
+ 'source': 'neo4j'
+ })
+ seen_nodes[label_name] = 'neo4j'
+
+ # Add edges from Neo4j
+ for e in neo4j_edges:
+ edge_key = (e.get('start_label'), e.get('rel_type'), e.get('end_label'))
+ if edge_key in seen_edges:
+ # Update existing edge with Neo4j count
+ for edge in result['edges']:
+ if (edge['start_label'], edge['rel_type'], edge['end_label']) == edge_key:
+ edge['count'] = e.get('c', 0)
+ edge['source'] = 'neo4j+labels' if edge['source'] == 'labels' else 'neo4j'
+ break
+ else:
+ result['edges'].append({
+ 'start_label': e.get('start_label'),
+ 'rel_type': e.get('rel_type'),
+ 'end_label': e.get('end_label'),
+ 'count': e.get('c', 0),
+ 'source': 'neo4j'
+ })
+ seen_edges[edge_key] = 'neo4j'
+
+ result['sources']['neo4j'] = {
+ 'count': len(neo4j_nodes),
+ 'enabled': True,
+ 'connected': True
+ }
+ finally:
+ if driver:
+ driver.close()
+ else:
+ result['sources']['neo4j'] = {'count': 0, 'enabled': False, 'connected': False}
+ except Exception as e:
+ result['sources']['neo4j'] = {
+ 'count': 0,
+ 'enabled': False,
+ 'connected': False,
+ 'error': str(e)
+ }
+
+ # 3. Get in-memory graph schema
+ if source in ('graph', 'all'):
+ try:
+ graph_schema = _get_ext()['graph'].schema_triples(limit=500)
+
+ for node in graph_schema.get('nodes', []):
+ label_name = node.get('label')
+ if label_name:
+ if label_name in seen_nodes:
+ # Update count for existing node
+ for n in result['nodes']:
+ if n['label'] == label_name:
+ n['count'] = node.get('count', 0)
+ if n['source'] == 'labels':
+ n['source'] = 'graph+labels'
+ elif n['source'] == 'neo4j':
+ n['source'] = 'graph+neo4j'
+ elif n['source'] == 'neo4j+labels':
+ n['source'] = 'all'
+ else:
+ n['source'] = 'graph'
+ break
+ else:
+ result['nodes'].append({
+ 'label': label_name,
+ 'count': node.get('count', 0),
+ 'source': 'graph'
+ })
+ seen_nodes[label_name] = 'graph'
+
+ for edge in graph_schema.get('edges', []):
+ edge_key = (edge.get('start_label'), edge.get('rel_type'), edge.get('end_label'))
+ if edge_key in seen_edges:
+ # Update count for existing edge
+ for e in result['edges']:
+ if (e['start_label'], e['rel_type'], e['end_label']) == edge_key:
+ e['count'] = edge.get('count', 0)
+ if e['source'] == 'labels':
+ e['source'] = 'graph+labels'
+ elif e['source'] == 'neo4j':
+ e['source'] = 'graph+neo4j'
+ elif e['source'] == 'neo4j+labels':
+ e['source'] = 'all'
+ else:
+ e['source'] = 'graph'
+ break
+ else:
+ result['edges'].append({
+ 'start_label': edge.get('start_label'),
+ 'rel_type': edge.get('rel_type'),
+ 'end_label': edge.get('end_label'),
+ 'count': edge.get('count', 0),
+ 'source': 'graph'
+ })
+ seen_edges[edge_key] = 'graph'
+
+ result['sources']['graph'] = {
+ 'count': len(graph_schema.get('nodes', [])),
+ 'enabled': True
+ }
+ except Exception as e:
+ result['sources']['graph'] = {'count': 0, 'enabled': False, 'error': str(e)}
+
+ return jsonify(result), 200
+
+
@bp.get('/graph/schema.csv')
def api_graph_schema_csv():
# Build a simple CSV with two sections: NodeLabels and RelationshipTypes
diff --git a/scidk/web/routes/api_labels.py b/scidk/web/routes/api_labels.py
index e207e41..8231a82 100644
--- a/scidk/web/routes/api_labels.py
+++ b/scidk/web/routes/api_labels.py
@@ -202,6 +202,38 @@ def push_label_to_neo4j(name):
}), 500
+@bp.route('/labels//pull', methods=['POST'])
+def pull_label_from_neo4j(name):
+ """
+ Pull properties for a specific label from Neo4j.
+
+ Returns:
+ {
+ "status": "success",
+ "label": {...},
+ "new_properties_count": 3
+ }
+ """
+ try:
+ service = _get_label_service()
+ result = service.pull_label_properties_from_neo4j(name)
+
+ if result.get('status') == 'error':
+ return jsonify(result), 500
+
+ return jsonify(result), 200
+ except ValueError as e:
+ return jsonify({
+ 'status': 'error',
+ 'error': str(e)
+ }), 404
+ except Exception as e:
+ return jsonify({
+ 'status': 'error',
+ 'error': str(e)
+ }), 500
+
+
@bp.route('/labels/pull', methods=['POST'])
def pull_labels_from_neo4j():
"""
@@ -255,3 +287,199 @@ def get_neo4j_schema():
'status': 'error',
'error': str(e)
}), 500
+
+
+@bp.route('/labels/import/arrows', methods=['POST'])
+def import_arrows_schema():
+ """
+ Import schema from Neo4j Arrows.app JSON format.
+
+ Request body:
+ {
+ "arrows_json": {...}, // Arrows.app JSON format
+ "mode": "merge" | "replace" // default: merge
+ }
+
+ Returns:
+ {
+ "status": "success",
+ "imported": {
+ "labels": 5,
+ "relationships": 8
+ },
+ "labels": [...] // Created label definitions
+ }
+ """
+ try:
+ from ...interpreters.arrows_utils import import_from_arrows
+
+ data = request.get_json(force=True, silent=True) or {}
+ arrows_json = data.get('arrows_json')
+ mode = data.get('mode', 'merge')
+
+ if not arrows_json:
+ return jsonify({'status': 'error', 'error': 'No arrows_json provided'}), 400
+
+ # Use arrows_utils to parse
+ labels_to_create = import_from_arrows(arrows_json)
+
+ # Create labels via service
+ service = _get_label_service()
+ created = []
+ skipped = []
+ for label_def in labels_to_create:
+ try:
+ result = service.save_label(label_def)
+ created.append(result)
+ except Exception as e:
+ # Skip duplicates if merge mode
+ if mode == 'merge':
+ skipped.append(label_def['name'])
+ continue
+ raise
+
+ total_relationships = sum(len(l.get('relationships', [])) for l in labels_to_create)
+
+ response = {
+ 'status': 'success',
+ 'imported': {'labels': len(created), 'relationships': total_relationships},
+ 'labels': created,
+ }
+
+ if skipped:
+ response['skipped'] = skipped
+
+ return jsonify(response), 200
+
+ except Exception as e:
+ return jsonify({'status': 'error', 'error': str(e)}), 500
+
+
+@bp.route('/labels/export/arrows', methods=['GET'])
+def export_arrows_schema():
+ """
+ Export schema to Neo4j Arrows.app JSON format.
+
+ Query params:
+ - layout: 'grid' or 'circular' (default: 'grid')
+ - scale: position scale factor (default: 1000)
+
+ Returns Arrows-compatible JSON file.
+ """
+ try:
+ from ...interpreters.arrows_utils import export_to_arrows
+
+ service = _get_label_service()
+ labels = service.list_labels()
+
+ layout = request.args.get('layout', 'grid')
+ scale = int(request.args.get('scale', 1000))
+
+ # Use arrows_utils to generate format
+ arrows_json = export_to_arrows(labels, layout=layout, scale=scale)
+
+ response = jsonify(arrows_json)
+ response.headers['Content-Disposition'] = 'attachment; filename=scidk-schema.json'
+ return response, 200
+
+ except Exception as e:
+ return jsonify({'status': 'error', 'error': str(e)}), 500
+
+
+@bp.route('/labels/batch/pull', methods=['POST'])
+def batch_pull_labels():
+ """
+ Pull schema from Neo4j for multiple labels.
+
+ Request body:
+ {
+ "label_names": ["Label1", "Label2", ...]
+ }
+
+ Returns:
+ {
+ "status": "success",
+ "results": [...],
+ "total_new_properties": 10,
+ "total_new_relationships": 5
+ }
+ """
+ try:
+ data = request.get_json(force=True, silent=True) or {}
+ label_names = data.get('label_names', [])
+
+ if not label_names:
+ return jsonify({'status': 'error', 'error': 'No label names provided'}), 400
+
+ service = _get_label_service()
+ results = []
+ total_new_properties = 0
+ total_new_relationships = 0
+
+ for name in label_names:
+ try:
+ result = service.pull_label_properties_from_neo4j(name)
+ results.append({'label': name, 'result': result})
+
+ if result.get('status') == 'success':
+ total_new_properties += result.get('new_properties_count', 0)
+ total_new_relationships += result.get('new_relationships_count', 0)
+ except Exception as e:
+ results.append({'label': name, 'result': {'status': 'error', 'error': str(e)}})
+
+ return jsonify({
+ 'status': 'success',
+ 'results': results,
+ 'total_new_properties': total_new_properties,
+ 'total_new_relationships': total_new_relationships
+ }), 200
+
+ except Exception as e:
+ return jsonify({'status': 'error', 'error': str(e)}), 500
+
+
+@bp.route('/labels/batch/delete', methods=['POST'])
+def batch_delete_labels():
+ """
+ Delete multiple labels.
+
+ Request body:
+ {
+ "label_names": ["Label1", "Label2", ...]
+ }
+
+ Returns:
+ {
+ "status": "success",
+ "deleted_count": 2,
+ "results": [...]
+ }
+ """
+ try:
+ data = request.get_json(force=True, silent=True) or {}
+ label_names = data.get('label_names', [])
+
+ if not label_names:
+ return jsonify({'status': 'error', 'error': 'No label names provided'}), 400
+
+ service = _get_label_service()
+ results = []
+ deleted_count = 0
+
+ for name in label_names:
+ try:
+ deleted = service.delete_label(name)
+ results.append({'label': name, 'deleted': deleted})
+ if deleted:
+ deleted_count += 1
+ except Exception as e:
+ results.append({'label': name, 'error': str(e)})
+
+ return jsonify({
+ 'status': 'success',
+ 'deleted_count': deleted_count,
+ 'results': results
+ }), 200
+
+ except Exception as e:
+ return jsonify({'status': 'error', 'error': str(e)}), 500
diff --git a/tests/conftest.py b/tests/conftest.py
index 9754298..76d9682 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -24,6 +24,9 @@ def _pin_repo_local_test_env():
# Clean up test scans from SQLite database
_cleanup_test_scans_from_db(db_dir / 'unit_integration.db')
+ # Clean up test labels from SQLite database
+ _cleanup_test_labels_from_db(db_dir / 'unit_integration.db')
+
# OS temp for tempfile and libraries
os.environ.setdefault("TMPDIR", str(tmp_root))
os.environ.setdefault("TMP", str(tmp_root))
@@ -127,6 +130,61 @@ def _cleanup_test_scans_from_db(db_path: Path):
pass # Silently fail; don't break test runs
+def _cleanup_test_labels_from_db(db_path: Path):
+ """Remove test labels from the SQLite database before test runs.
+
+ This prevents accumulation of test labels that show up in the UI
+ when running scidk-serve after tests have run.
+
+ Args:
+ db_path: Path to the SQLite database file
+ """
+ if not db_path.exists():
+ return
+
+ try:
+ import sqlite3
+ conn = sqlite3.connect(str(db_path))
+ try:
+ cur = conn.cursor()
+
+ # Check if label_definitions table exists
+ cur.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='label_definitions'")
+ if not cur.fetchone():
+ return
+
+ # List of test label patterns to delete
+ test_patterns = [
+ 'E2E%', # E2E test labels
+ 'Test%', # TestLabel, TestNode, etc
+ 'Person%', # From arrows test
+ 'Company%', # From arrows test
+ 'Project%', # Multiple test uses
+ 'Export%', # ExportProject, ExportTask
+ 'Layout%', # LayoutTestLabel
+ 'Roundtrip%', # RoundtripAuthor, RoundtripBook
+ 'Label%', # Label1, Label2, Label3
+ 'AllTypes%', # AllTypes
+ 'File%', # File from relationship tests
+ 'Directory%', # Directory from relationship tests
+ 'User%', # User from relationship tests
+ 'Update%', # UpdateTest
+ 'Delete%', # DeleteTest
+ 'Bad%', # BadLabel
+ 'Node%', # TestNode, OtherNode, NodeA, NodeB
+ ]
+
+ # Delete test labels
+ for pattern in test_patterns:
+ cur.execute("DELETE FROM label_definitions WHERE name LIKE ?", (pattern,))
+
+ conn.commit()
+ finally:
+ conn.close()
+ except Exception:
+ pass # Silently fail; don't break test runs
+
+
# --- Flask app + test client fixtures expected by unit/integration tests ---
@pytest.fixture(scope="function")
def app():
diff --git a/tests/test_arrows_import_export.py b/tests/test_arrows_import_export.py
new file mode 100644
index 0000000..8a612e1
--- /dev/null
+++ b/tests/test_arrows_import_export.py
@@ -0,0 +1,304 @@
+"""
+Tests for Arrows.app schema import/export functionality.
+"""
+
+import pytest
+
+
+@pytest.fixture
+def arrows_json_sample():
+ """Sample Arrows.app JSON format"""
+ return {
+ 'style': {},
+ 'nodes': [
+ {
+ 'id': 'n0',
+ 'caption': 'Person',
+ 'labels': ['Person'],
+ 'properties': {'name': 'String', 'age': 'Integer'},
+ 'position': {'x': 100, 'y': 200},
+ },
+ {
+ 'id': 'n1',
+ 'caption': 'Company',
+ 'labels': ['Company'],
+ 'properties': {'name': 'String', 'founded': 'Integer'},
+ 'position': {'x': 300, 'y': 200},
+ },
+ ],
+ 'relationships': [
+ {
+ 'id': 'r0',
+ 'type': 'WORKS_FOR',
+ 'fromId': 'n0',
+ 'toId': 'n1',
+ 'properties': {'since': 'Date'},
+ }
+ ],
+ }
+
+
+def test_import_arrows_schema(client, arrows_json_sample):
+ """Test importing Arrows.app JSON creates labels correctly"""
+ resp = client.post('/api/labels/import/arrows', json={'arrows_json': arrows_json_sample})
+
+ assert resp.status_code == 200
+ data = resp.json
+ assert data['status'] == 'success'
+ assert data['imported']['labels'] == 2
+ assert data['imported']['relationships'] == 1
+
+ # Verify labels were created
+ resp = client.get('/api/labels')
+ labels = resp.json['labels']
+
+ person_label = next((l for l in labels if l['name'] == 'Person'), None)
+ assert person_label is not None
+ assert len(person_label['properties']) == 2
+ assert any(p['name'] == 'name' and p['type'] == 'string' for p in person_label['properties'])
+ assert any(p['name'] == 'age' and p['type'] == 'number' for p in person_label['properties'])
+ assert len(person_label['relationships']) == 1
+ assert person_label['relationships'][0]['type'] == 'WORKS_FOR'
+ assert person_label['relationships'][0]['target_label'] == 'Company'
+
+ company_label = next((l for l in labels if l['name'] == 'Company'), None)
+ assert company_label is not None
+ assert len(company_label['properties']) == 2
+
+
+def test_import_arrows_missing_json(client):
+ """Test import fails gracefully when no JSON provided"""
+ resp = client.post('/api/labels/import/arrows', json={})
+ assert resp.status_code == 400
+ assert 'No arrows_json provided' in resp.json['error']
+
+
+def test_import_arrows_merge_mode_skips_duplicates(client, arrows_json_sample):
+ """Test merge mode skips existing labels without error"""
+ # First import
+ resp1 = client.post('/api/labels/import/arrows', json={'arrows_json': arrows_json_sample, 'mode': 'merge'})
+ assert resp1.status_code == 200
+ assert resp1.json['imported']['labels'] == 2
+
+ # Second import (should skip duplicates)
+ resp2 = client.post('/api/labels/import/arrows', json={'arrows_json': arrows_json_sample, 'mode': 'merge'})
+ assert resp2.status_code == 200
+ # May import 0 or 2 depending on whether save_label updates or errors
+ # But should not crash
+ assert resp2.json['status'] == 'success'
+
+
+def test_export_arrows_schema(client):
+ """Test exporting labels to Arrows.app JSON format"""
+ # Create labels
+ client.post(
+ '/api/labels',
+ json={
+ 'name': 'ExportProject',
+ 'properties': [{'name': 'title', 'type': 'string', 'required': True}],
+ 'relationships': [{'type': 'HAS_TASK', 'target_label': 'ExportTask', 'properties': []}],
+ },
+ )
+
+ client.post(
+ '/api/labels',
+ json={
+ 'name': 'ExportTask',
+ 'properties': [{'name': 'description', 'type': 'string', 'required': False}],
+ 'relationships': [],
+ },
+ )
+
+ # Export
+ resp = client.get('/api/labels/export/arrows')
+ assert resp.status_code == 200
+
+ arrows_json = resp.json
+ assert 'nodes' in arrows_json
+ assert 'relationships' in arrows_json
+ assert 'style' in arrows_json
+
+ # Verify our specific nodes exist (there may be others from previous tests)
+ project_node = next((n for n in arrows_json['nodes'] if n['caption'] == 'ExportProject'), None)
+ assert project_node is not None
+ assert project_node['labels'] == ['ExportProject']
+ assert 'title' in project_node['properties']
+ assert project_node['properties']['title'] == 'String'
+ assert 'position' in project_node
+
+ task_node = next((n for n in arrows_json['nodes'] if n['caption'] == 'ExportTask'), None)
+ assert task_node is not None
+
+ # Verify our relationship exists
+ rel = next((r for r in arrows_json['relationships'] if r['type'] == 'HAS_TASK' and r['fromId'] == project_node['id']), None)
+ assert rel is not None
+ assert rel['toId'] == task_node['id']
+
+ # Cleanup
+ client.delete('/api/labels/ExportProject')
+ client.delete('/api/labels/ExportTask')
+
+
+def test_export_arrows_empty_schema(client):
+ """Test exporting works even when no labels exist (or just verifies structure)"""
+ resp = client.get('/api/labels/export/arrows')
+ assert resp.status_code == 200
+
+ arrows_json = resp.json
+ # Verify structure exists (may have labels from other tests)
+ assert 'nodes' in arrows_json
+ assert 'relationships' in arrows_json
+ assert 'style' in arrows_json
+ assert isinstance(arrows_json['nodes'], list)
+ assert isinstance(arrows_json['relationships'], list)
+
+
+def test_export_arrows_with_layout_params(client):
+ """Test export with layout and scale parameters"""
+ # Create a label with unique name
+ client.post('/api/labels', json={'name': 'LayoutTestLabel', 'properties': [], 'relationships': []})
+
+ # Export with circular layout
+ resp = client.get('/api/labels/export/arrows?layout=circular&scale=500')
+ assert resp.status_code == 200
+
+ arrows_json = resp.json
+ # Verify our label exists and has position
+ test_node = next((n for n in arrows_json['nodes'] if n['caption'] == 'LayoutTestLabel'), None)
+ assert test_node is not None
+ assert 'position' in test_node
+
+ # Cleanup
+ client.delete('/api/labels/LayoutTestLabel')
+
+
+def test_arrows_utils_type_mapping():
+ """Test type conversions between Arrows and scidk formats"""
+ from scidk.interpreters.arrows_utils import ARROWS_TO_SCIDK_TYPE, SCIDK_TO_ARROWS_TYPE
+
+ # Arrows -> scidk
+ assert ARROWS_TO_SCIDK_TYPE['String'] == 'string'
+ assert ARROWS_TO_SCIDK_TYPE['Integer'] == 'number'
+ assert ARROWS_TO_SCIDK_TYPE['Boolean'] == 'boolean'
+
+ # scidk -> Arrows
+ assert SCIDK_TO_ARROWS_TYPE['string'] == 'String'
+ assert SCIDK_TO_ARROWS_TYPE['number'] == 'Integer'
+ assert SCIDK_TO_ARROWS_TYPE['boolean'] == 'Boolean'
+
+
+def test_arrows_utils_import_function():
+ """Test the import_from_arrows utility function directly"""
+ from scidk.interpreters.arrows_utils import import_from_arrows
+
+ arrows_json = {
+ 'nodes': [
+ {'id': 'n0', 'caption': 'TestNode', 'properties': {'prop1': 'String'}},
+ {'id': 'n1', 'caption': 'OtherNode', 'properties': {}},
+ ],
+ 'relationships': [{'id': 'r0', 'type': 'RELATES_TO', 'fromId': 'n0', 'toId': 'n1'}],
+ }
+
+ labels = import_from_arrows(arrows_json)
+
+ assert len(labels) == 2
+ test_label = next((l for l in labels if l['name'] == 'TestNode'), None)
+ assert test_label is not None
+ assert len(test_label['properties']) == 1
+ assert test_label['properties'][0]['name'] == 'prop1'
+ assert test_label['properties'][0]['type'] == 'string'
+ assert len(test_label['relationships']) == 1
+ assert test_label['relationships'][0]['type'] == 'RELATES_TO'
+ assert test_label['relationships'][0]['target_label'] == 'OtherNode'
+
+
+def test_arrows_utils_export_function():
+ """Test the export_to_arrows utility function directly"""
+ from scidk.interpreters.arrows_utils import export_to_arrows
+
+ labels = [
+ {
+ 'name': 'NodeA',
+ 'properties': [{'name': 'field1', 'type': 'string'}],
+ 'relationships': [{'type': 'LINKS_TO', 'target_label': 'NodeB'}],
+ },
+ {'name': 'NodeB', 'properties': [], 'relationships': []},
+ ]
+
+ arrows_json = export_to_arrows(labels, layout='grid', scale=1000)
+
+ assert 'nodes' in arrows_json
+ assert 'relationships' in arrows_json
+ assert 'style' in arrows_json
+ assert len(arrows_json['nodes']) == 2
+ assert len(arrows_json['relationships']) == 1
+
+ node_a = next((n for n in arrows_json['nodes'] if n['caption'] == 'NodeA'), None)
+ assert node_a is not None
+ assert 'field1' in node_a['properties']
+ assert node_a['properties']['field1'] == 'String'
+
+
+def test_roundtrip_import_export(client):
+ """Test that exporting and re-importing preserves schema"""
+ # Create original labels with unique names
+ client.post(
+ '/api/labels',
+ json={
+ 'name': 'RoundtripAuthor',
+ 'properties': [{'name': 'name', 'type': 'string'}],
+ 'relationships': [{'type': 'WROTE', 'target_label': 'RoundtripBook'}],
+ },
+ )
+ client.post(
+ '/api/labels', json={'name': 'RoundtripBook', 'properties': [{'name': 'title', 'type': 'string'}], 'relationships': []}
+ )
+
+ # Export
+ export_resp = client.get('/api/labels/export/arrows')
+ exported_json = export_resp.json
+
+ # Extract only our test labels from the export
+ our_labels = {
+ 'nodes': [n for n in exported_json['nodes'] if n['caption'] in ['RoundtripAuthor', 'RoundtripBook']],
+ 'relationships': [],
+ 'style': exported_json['style'],
+ }
+
+ # Find our nodes' IDs
+ author_node_id = next((n['id'] for n in our_labels['nodes'] if n['caption'] == 'RoundtripAuthor'), None)
+ book_node_id = next((n['id'] for n in our_labels['nodes'] if n['caption'] == 'RoundtripBook'), None)
+
+ # Extract only relationships between our nodes
+ our_labels['relationships'] = [
+ r
+ for r in exported_json['relationships']
+ if r['fromId'] == author_node_id and r['toId'] == book_node_id and r['type'] == 'WROTE'
+ ]
+
+ # Delete labels
+ client.delete('/api/labels/RoundtripAuthor')
+ client.delete('/api/labels/RoundtripBook')
+
+ # Verify our labels are deleted
+ resp = client.get('/api/labels')
+ labels = resp.json['labels']
+ assert not any(l['name'] in ['RoundtripAuthor', 'RoundtripBook'] for l in labels)
+
+ # Re-import only our labels
+ import_resp = client.post('/api/labels/import/arrows', json={'arrows_json': our_labels})
+ assert import_resp.status_code == 200
+ assert import_resp.json['imported']['labels'] == 2
+
+ # Verify re-imported correctly
+ resp = client.get('/api/labels')
+ labels = resp.json['labels']
+
+ author = next((l for l in labels if l['name'] == 'RoundtripAuthor'), None)
+ assert author is not None
+ assert len(author['relationships']) == 1
+ assert author['relationships'][0]['type'] == 'WROTE'
+
+ # Cleanup
+ client.delete('/api/labels/RoundtripAuthor')
+ client.delete('/api/labels/RoundtripBook')
diff --git a/tests/test_graph_combined_schema_api.py b/tests/test_graph_combined_schema_api.py
new file mode 100644
index 0000000..91fa6e9
--- /dev/null
+++ b/tests/test_graph_combined_schema_api.py
@@ -0,0 +1,236 @@
+"""
+Unit tests for the combined schema API endpoint.
+
+Tests the /api/graph/schema/combined endpoint that merges:
+- Local Labels definitions
+- Neo4j schema (when connected)
+- In-memory graph schema
+"""
+import pytest
+import json
+
+
+def test_combined_schema_all_sources_default(client):
+ """Test combined schema with default 'all' sources."""
+ resp = client.get('/api/graph/schema/combined')
+ assert resp.status_code == 200
+
+ data = resp.json
+ assert 'nodes' in data
+ assert 'edges' in data
+ assert 'sources' in data
+ assert isinstance(data['nodes'], list)
+ assert isinstance(data['edges'], list)
+ assert isinstance(data['sources'], dict)
+
+
+def test_combined_schema_labels_only(client, app):
+ """Test combined schema with only local labels."""
+ # Create test labels using the label service
+ from scidk.services.label_service import LabelService
+
+ with app.app_context():
+ label_service = LabelService(app)
+
+ # Create a test label with properties and relationships
+ label_service.save_label({
+ 'name': 'TestProject',
+ 'properties': [
+ {'name': 'project_id', 'type': 'string', 'required': True},
+ {'name': 'budget', 'type': 'number', 'required': False}
+ ],
+ 'relationships': [
+ {'type': 'HAS_FILE', 'target_label': 'File', 'properties': []}
+ ]
+ })
+
+ # Create another label
+ label_service.save_label({
+ 'name': 'TestDataset',
+ 'properties': [
+ {'name': 'dataset_name', 'type': 'string'}
+ ],
+ 'relationships': []
+ })
+
+ # Fetch combined schema with labels source only
+ resp = client.get('/api/graph/schema/combined?source=labels')
+ assert resp.status_code == 200
+
+ data = resp.json
+
+ # Verify TestProject label exists
+ test_project = next((n for n in data['nodes'] if n['label'] == 'TestProject'), None)
+ assert test_project is not None
+ assert test_project['count'] == 0 # No instances yet
+ assert test_project['source'] == 'labels'
+
+ # Verify TestDataset label exists
+ test_dataset = next((n for n in data['nodes'] if n['label'] == 'TestDataset'), None)
+ assert test_dataset is not None
+ assert test_dataset['source'] == 'labels'
+
+ # Verify HAS_FILE relationship exists from TestProject
+ has_file_edge = next((e for e in data['edges'] if e['rel_type'] == 'HAS_FILE' and e['start_label'] == 'TestProject'), None)
+ assert has_file_edge is not None
+ assert has_file_edge['end_label'] == 'File'
+ assert has_file_edge['count'] == 0
+ assert has_file_edge['source'] == 'labels'
+
+ # Verify sources metadata
+ assert 'labels' in data['sources']
+ assert data['sources']['labels']['enabled'] is True
+ assert data['sources']['labels']['count'] >= 2 # At least our 2 test labels
+
+
+def test_combined_schema_graph_only(client, graph_with_data):
+ """Test combined schema with only in-memory graph."""
+ resp = client.get('/api/graph/schema/combined?source=graph')
+ assert resp.status_code == 200
+
+ data = resp.json
+
+ # Graph may or may not have nodes depending on test fixtures
+ # Just verify the response structure is correct
+ assert 'nodes' in data
+ assert 'edges' in data
+ assert isinstance(data['nodes'], list)
+ assert isinstance(data['edges'], list)
+
+ # All nodes should have source='graph' if any exist
+ for node in data['nodes']:
+ assert node['source'] == 'graph'
+ assert node['count'] >= 0
+
+ # Verify sources metadata
+ assert 'graph' in data['sources']
+ assert data['sources']['graph']['enabled'] is True
+
+
+def test_combined_schema_include_properties(client, app):
+ """Test include_properties parameter."""
+ from scidk.services.label_service import LabelService
+
+ with app.app_context():
+ label_service = LabelService(app)
+
+ label_service.save_label({
+ 'name': 'PropertyTest',
+ 'properties': [
+ {'name': 'prop1', 'type': 'string'},
+ {'name': 'prop2', 'type': 'integer'}
+ ],
+ 'relationships': []
+ })
+
+ # Without include_properties (default false)
+ resp = client.get('/api/graph/schema/combined?source=labels')
+ data = resp.json
+ prop_test = next((n for n in data['nodes'] if n['label'] == 'PropertyTest'), None)
+ assert prop_test is not None
+ assert 'properties' not in prop_test
+
+ # With include_properties=true
+ resp = client.get('/api/graph/schema/combined?source=labels&include_properties=true')
+ data = resp.json
+ prop_test = next((n for n in data['nodes'] if n['label'] == 'PropertyTest'), None)
+ assert prop_test is not None
+ assert 'properties' in prop_test
+ assert len(prop_test['properties']) == 2
+ assert prop_test['properties'][0]['name'] in ['prop1', 'prop2']
+
+
+def test_combined_schema_invalid_source(client):
+ """Test with invalid source parameter."""
+ resp = client.get('/api/graph/schema/combined?source=invalid')
+ assert resp.status_code == 200
+
+ data = resp.json
+ # Should return empty results for unknown source
+ assert data['nodes'] == []
+ assert data['edges'] == []
+
+
+def test_combined_schema_neo4j_not_connected(client):
+ """Test Neo4j source when not connected."""
+ resp = client.get('/api/graph/schema/combined?source=neo4j')
+ assert resp.status_code == 200
+
+ data = resp.json
+
+ # Verify neo4j source shows as not connected
+ assert 'neo4j' in data['sources']
+ assert data['sources']['neo4j']['enabled'] is False
+ assert data['sources']['neo4j']['connected'] is False
+
+
+def test_combined_schema_merges_sources(client, app, graph_with_data):
+ """Test that 'all' source merges labels and graph correctly."""
+ from scidk.services.label_service import LabelService
+
+ with app.app_context():
+ label_service = LabelService(app)
+
+ # Create a label not in graph
+ label_service.save_label({
+ 'name': 'CustomMergeTest',
+ 'properties': [],
+ 'relationships': []
+ })
+
+ resp = client.get('/api/graph/schema/combined?source=all')
+ data = resp.json
+
+ # CustomMergeTest should exist with source='labels' and count=0
+ custom_node = next((n for n in data['nodes'] if n['label'] == 'CustomMergeTest'), None)
+ assert custom_node is not None
+ assert custom_node['count'] == 0
+ assert custom_node['source'] == 'labels'
+
+ # Verify both sources are present in metadata
+ assert 'labels' in data['sources']
+ assert 'graph' in data['sources']
+
+ # Labels source should be enabled and have at least our test label
+ assert data['sources']['labels']['enabled'] is True
+ assert data['sources']['labels']['count'] >= 1
+
+
+def test_combined_schema_empty_labels(client):
+ """Test combined schema when no labels are defined."""
+ resp = client.get('/api/graph/schema/combined?source=labels')
+ assert resp.status_code == 200
+
+ data = resp.json
+ assert 'sources' in data
+ assert 'labels' in data['sources']
+ # May have 0 labels or may have some from previous tests
+ assert data['sources']['labels']['count'] >= 0
+
+
+def test_combined_schema_case_sensitive_params(client):
+ """Test parameter case sensitivity."""
+ # Test various case variations
+ for source in ['all', 'ALL', 'All', 'labels', 'LABELS', 'Labels']:
+ resp = client.get(f'/api/graph/schema/combined?source={source}')
+ assert resp.status_code == 200
+ data = resp.json
+ assert 'nodes' in data
+ assert 'edges' in data
+ assert 'sources' in data
+
+
+@pytest.fixture
+def graph_with_data(app):
+ """Fixture that populates the in-memory graph with test data."""
+ with app.app_context():
+ graph = app.extensions['scidk']['graph']
+
+ # Add some test nodes and edges to the graph
+ # This assumes graph has methods to add data
+ # Adjust based on actual graph API
+ if hasattr(graph, 'datasets'):
+ # Add a few test datasets
+ pass # Graph should have data from other fixtures
+
+ return app
diff --git a/tests/test_labels_api.py b/tests/test_labels_api.py
index 5c8e770..04cda49 100644
--- a/tests/test_labels_api.py
+++ b/tests/test_labels_api.py
@@ -247,3 +247,194 @@ def test_get_neo4j_schema(client):
assert response.status_code in [200, 500]
data = response.get_json()
assert 'status' in data
+
+
+def test_pull_all_labels_from_neo4j(client):
+ """Test pulling all labels from Neo4j."""
+ response = client.post('/api/labels/pull')
+ # Either success (if Neo4j configured) or error (if not)
+ assert response.status_code in [200, 500]
+ data = response.get_json()
+ assert 'status' in data
+
+ # If successful, should have imported_labels and count
+ if response.status_code == 200:
+ assert 'imported_labels' in data or 'count' in data
+
+
+def test_pull_single_label_not_found(client):
+ """Test pulling non-existent label from Neo4j."""
+ response = client.post('/api/labels/NonExistent/pull')
+ # Should return 404 since label doesn't exist
+ assert response.status_code == 404
+ data = response.get_json()
+ assert data['status'] == 'error'
+
+
+def test_pull_single_label_from_neo4j(client):
+ """Test pulling single label properties from Neo4j."""
+ # First create a label
+ payload = {
+ 'name': 'PullTest',
+ 'properties': [{'name': 'initial_prop', 'type': 'string', 'required': False}],
+ 'relationships': []
+ }
+ client.post('/api/labels', json=payload)
+
+ # Try to pull from Neo4j
+ response = client.post('/api/labels/PullTest/pull')
+ # Either success (if Neo4j configured) or error (if not)
+ assert response.status_code in [200, 500]
+ data = response.get_json()
+ assert 'status' in data
+
+ # If successful, should have label and new_properties_count
+ if response.status_code == 200:
+ assert 'label' in data
+ assert 'new_properties_count' in data
+
+
+def test_batch_pull_labels_success(client):
+ """Test batch pulling multiple labels from Neo4j."""
+ # Create test labels
+ for name in ['BatchPull1', 'BatchPull2']:
+ payload = {
+ 'name': name,
+ 'properties': [{'name': 'test', 'type': 'string', 'required': False}],
+ 'relationships': []
+ }
+ client.post('/api/labels', json=payload)
+
+ # Batch pull
+ response = client.post('/api/labels/batch/pull', json={
+ 'label_names': ['BatchPull1', 'BatchPull2']
+ })
+
+ # Either success (if Neo4j configured) or error (if not)
+ assert response.status_code in [200, 500]
+ data = response.get_json()
+ assert 'status' in data
+
+ # If successful, should have results
+ if response.status_code == 200:
+ assert 'results' in data
+ assert 'total_new_properties' in data
+ assert 'total_new_relationships' in data
+ assert len(data['results']) == 2
+
+
+def test_batch_pull_labels_empty_list(client):
+ """Test batch pull with empty label list."""
+ response = client.post('/api/labels/batch/pull', json={
+ 'label_names': []
+ })
+ assert response.status_code == 400
+ data = response.get_json()
+ assert data['status'] == 'error'
+ assert 'no label names' in data['error'].lower()
+
+
+def test_batch_pull_labels_missing_field(client):
+ """Test batch pull without label_names field."""
+ response = client.post('/api/labels/batch/pull', json={})
+ assert response.status_code == 400
+ data = response.get_json()
+ assert data['status'] == 'error'
+
+
+def test_push_label_to_neo4j(client):
+ """Test pushing label to Neo4j."""
+ # Create a label
+ payload = {
+ 'name': 'PushTest',
+ 'properties': [
+ {'name': 'name', 'type': 'string', 'required': True},
+ {'name': 'age', 'type': 'number', 'required': False}
+ ],
+ 'relationships': []
+ }
+ client.post('/api/labels', json=payload)
+
+ # Push to Neo4j
+ response = client.post('/api/labels/PushTest/push')
+ # Either success (if Neo4j configured) or error (if not)
+ assert response.status_code in [200, 500]
+ data = response.get_json()
+ assert 'status' in data
+
+ # If successful, should have constraints/indexes info
+ if response.status_code == 200:
+ assert 'label' in data
+ assert data['label'] == 'PushTest'
+
+
+def test_batch_delete_labels_success(client):
+ """Test batch deleting multiple labels."""
+ # Create test labels
+ for name in ['DeleteBatch1', 'DeleteBatch2', 'DeleteBatch3']:
+ payload = {
+ 'name': name,
+ 'properties': [],
+ 'relationships': []
+ }
+ client.post('/api/labels', json=payload)
+
+ # Batch delete
+ response = client.post('/api/labels/batch/delete', json={
+ 'label_names': ['DeleteBatch1', 'DeleteBatch2', 'DeleteBatch3']
+ })
+ assert response.status_code == 200
+ data = response.get_json()
+ assert data['status'] == 'success'
+ assert 'deleted_count' in data
+ assert data['deleted_count'] == 3
+ assert 'results' in data
+
+ # Verify labels are deleted
+ for name in ['DeleteBatch1', 'DeleteBatch2', 'DeleteBatch3']:
+ get_response = client.get(f'/api/labels/{name}')
+ assert get_response.status_code == 404
+
+
+def test_batch_delete_labels_empty_list(client):
+ """Test batch delete with empty label list."""
+ response = client.post('/api/labels/batch/delete', json={
+ 'label_names': []
+ })
+ assert response.status_code == 400
+ data = response.get_json()
+ assert data['status'] == 'error'
+ assert 'no label names' in data['error'].lower()
+
+
+def test_batch_delete_labels_missing_field(client):
+ """Test batch delete without label_names field."""
+ response = client.post('/api/labels/batch/delete', json={})
+ assert response.status_code == 400
+ data = response.get_json()
+ assert data['status'] == 'error'
+
+
+def test_batch_delete_labels_partial_success(client):
+ """Test batch delete with some non-existent labels."""
+ # Create only one label
+ payload = {
+ 'name': 'DeleteExists',
+ 'properties': [],
+ 'relationships': []
+ }
+ client.post('/api/labels', json=payload)
+
+ # Try to delete both existing and non-existent
+ response = client.post('/api/labels/batch/delete', json={
+ 'label_names': ['DeleteExists', 'NonExistent']
+ })
+ assert response.status_code == 200
+ data = response.get_json()
+ assert data['status'] == 'success'
+ assert 'results' in data
+ assert len(data['results']) == 2
+
+ # Verify the existing label was deleted
+ get_response = client.get('/api/labels/DeleteExists')
+ assert get_response.status_code == 404