From 156101d0960858462c3f040d2a807dfb85eba511 Mon Sep 17 00:00:00 2001
From: wdednam <wdednam@gmail.com>
Date: Wed, 9 Oct 2024 13:09:27 +0200
Subject: [PATCH 1/6] Update .gitignore and remove build artifacts from
 tracking

---
 .gitignore | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/.gitignore b/.gitignore
index 55a5dada6..ca742241c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -41,3 +41,35 @@ gui-js/dist/*
 gui-js/.nx/*
 gui-js/.angular/*
 doc/minsky/*
+
+# Ignore build artifacts and temporary files
+# Object files, static and shared libraries, executables
+*.o
+*.a
+*.so
+*.dll
+*.exe
+*.gch
+*.node
+
+# Build directories
+/build/
+/bin/
+/obj/
+
+# Logs and temporary files
+*.log
+*.tmp
+*.pid
+*.swp
+*.swo
+
+# Core dumps
+core
+
+# Exclude specific large files
+/gui-js/node-addons/minskyRESTService.node
+/model/minsky.gch
+/libminsky.a
+/st1QD5JV
+

From 2b420027e77780d644e7602c082f9b7aeaa163b0 Mon Sep 17 00:00:00 2001
From: wdednam <wdednam@gmail.com>
Date: Wed, 9 Oct 2024 21:28:28 +0200
Subject: [PATCH 2/6] First attempts at porting tcl tests to python

---
 test/00/canvasContext.sh | 117 ++++++++++++++++++++-------------------
 test/00/instanceList.sh  |  67 ++++++++++++----------
 2 files changed, 97 insertions(+), 87 deletions(-)

diff --git a/test/00/canvasContext.sh b/test/00/canvasContext.sh
index f9944ec67..540b73d9d 100755
--- a/test/00/canvasContext.sh
+++ b/test/00/canvasContext.sh
@@ -4,76 +4,77 @@ here=`pwd`
 . $here/test/common-test.sh
 
 # needs to be a jest test!
-cat >input.tcl <<EOF
-source $here/test/assert.tcl
-proc afterMinskyStarted {} {
-  canvasContext 0 0 0 0
-  assert {[winfo ismapped .wiring.context]}
-  .wiring.context unpost
+cat >input.py <<EOF
+import sys
 
-  assert {![winfo ismapped .wiring.context]}
-  wireContextMenu 0 0
-  assert {[winfo ismapped .wiring.context]}
-   .wiring.context unpost
+sys.path.insert(0,'$here')
 
-  # need to check context on all types of items
-  minsky.addVariable foo flow
-  assert {[findObject Variable:flow]}
-  contextMenu 0 0 0 0
-  assert {[winfo ismapped .wiring.context]} "variable"
-  .wiring.context unpost
-  assert {![winfo ismapped .wiring.context]}
+from pyminsky import minsky
 
-  minsky.addOperation integrate
-  assert {[findObject IntOp]}
-  contextMenu 0 0 0 0
-  assert {[winfo ismapped .wiring.context]} "operation"
-  .wiring.context unpost
+def assert_condition(condition, message=""):
+    if not condition:
+        print(f"Assertion failed: {message}")
+        sys.exit(1)
 
-  minsky.addOperation data
-  assert {[findObject DataOp]}
-  contextMenu 0 0 0 0
-  assert {[winfo ismapped .wiring.context]} "data operation"
-  .wiring.context unpost
+# Clear the model
+minsky.model.clear()
 
+# List of items to test
+items_to_test = [
+    ('Variable', 'foo', 'flow', 'Variable:flow'),
+    ('Operation', 'integrate', None, 'IntOp'),
+    ('Operation', 'data', None, 'DataOp'),
+    ('Plot', None, None, 'PlotWidget'),
+    ('Godley', None, None, 'GodleyIcon'),
+    ('Group', None, None, 'Group'),
+    ('Note', 'hello', None, 'Item'),
+    ('Switch', None, None, 'SwitchIcon'),
+]
 
+# Keep track of added items for verification
+added_items = []
 
-  minsky.addPlot
-  assert {[findObject PlotWidget]}
-  contextMenu 0 0 0 0
-  assert {[winfo ismapped .wiring.context]} "plot"
-  .wiring.context unpost
+for item_type, name, var_type, expected_class in items_to_test:
+    # Add the item
+    if item_type == 'Variable':
+        minsky.canvas.addVariable(name, var_type)
+    elif item_type == 'Operation':
+        minsky.canvas.addOperation(name)
+    elif item_type == 'Plot':
+        minsky.canvas.addPlot()
+    elif item_type == 'Godley':
+        minsky.canvas.addGodley()
+    elif item_type == 'Group':
+        minsky.canvas.addGroup()
+    elif item_type == 'Note':
+        minsky.canvas.addNote(name)
+    elif item_type == 'Switch':
+        minsky.canvas.addSwitch()
+    else:
+        print(f"Unknown item type: {item_type}")
+        sys.exit(1)
+    
+    # The newly added item should be the item in focus
+    item = minsky.canvas.itemFocus()
+    assert_condition(item is not None, f"{item_type} not added correctly")
+    assert_condition(item.classType() == expected_class,
+                     f"{item_type} class type mismatch: expected {expected_class}, got {item.classType()}")
+    # Store the item for further checks
+    added_items.append(item)
 
-  minsky.addGodley
-  assert {[findObject GodleyIcon]}
-  contextMenu 0 0 0 0
-  assert {[winfo ismapped .wiring.context]} "godley"
-  .wiring.context unpost
+# Verify that added items are present in the model
+# Get the number of items in the model
+item_count = len(minsky.model.items)
 
-  minsky.addGroup
-  assert {[findObject Group]}
-  contextMenu 0 0 0 0
-  assert {[winfo ismapped .wiring.context]} "group"
-  .wiring.context unpost
-  
-  minsky.addNote "hello"
-  assert {[findObject Item]}
-  contextMenu 0 0 0 0
-  assert {[winfo ismapped .wiring.context]} "note"
-  .wiring.context unpost
+# Collect IDs of items in model
+model_item_ids = [minsky.model.items[idx].id() for idx in range(item_count)]
 
-  minsky.addSwitch
-  assert {[findObject SwitchIcon]}
-  contextMenu 0 0 0 0
-  assert {[winfo ismapped .wiring.context]} "switch"
-  .wiring.context unpost
-  
-
-  tcl_exit
-}
+# Verify that all added items are in the model
+for item in added_items:
+    assert_condition(item.id() in model_item_ids, f"Item with ID {item.id()} not found in model items")
 EOF
 
-$here/gui-tk/minsky input.tcl
+python3 input.py
 if [ $? -ne 0 ]; then fail; fi
 
 pass
diff --git a/test/00/instanceList.sh b/test/00/instanceList.sh
index ef9e23a70..d88c2941a 100644
--- a/test/00/instanceList.sh
+++ b/test/00/instanceList.sh
@@ -27,37 +27,46 @@ pass()
 }
 
 trap "fail" 1 2 3 15
-cat >input.tcl <<EOF
-source $here/test/assert.tcl
-minsky.load $here/examples/GoodwinLinear02.mky
-minsky.findVariable "Y"
-set instanceList [minsky.listAllInstances]
-assert "[llength [\$instanceList.names]]==2"
-set offsx [minsky.model.x]
-set offsy [minsky.model.y]
-\$instanceList.gotoInstance 0
-set offsx0 [minsky.model.x]
-set offsy0 [minsky.model.y]
-assert "\$offsx0!=\$offsx"
-assert "\$offsy0!=\$offsy"
-
-
-# offsets hard coded in VariableInstanceList
-minsky.canvas.getItemAt [expr \$offsx-[minsky.model.x]+50] [expr \$offsy-[minsky.model.y]+50]
-assert {[minsky.canvas.item.name]=="Y"}
-
-\$instanceList.gotoInstance 1
-assert "[minsky.model.x]!=\$offsx0"
-assert "[minsky.model.y]!=\$offsy0"
-
-minsky.canvas.getItemAt [expr \$offsx-[minsky.model.x]+50] [expr \$offsy-[minsky.model.y]+50]
-assert {[minsky.canvas.item.name]=="Y"}
-
-assert "[catch \$instanceList.gotoInstance 2]"
-tcl_exit
+cat >input.py <<EOF
+import sys
+
+# Add the directory containing pyminsky.so to sys.path
+sys.path.insert(0,'$here')
+
+from pyminsky import minsky
+
+def assert_condition(condition, message=""):
+    if not condition:
+        print(f"Assertion failed: {message}")
+        sys.exit(1)
+# Load the model
+minsky.load('/home/dednaw/minsky/examples/GoodwinLinear02.mky')
+
+# Get the number of items in the model
+item_count = len(minsky.model.items)
+
+# Find all variables named "Y"
+variables_Y = []
+for idx in range(item_count):
+    item = minsky.model.items[idx]
+    if item.classType().startswith("Variable:") and item.name() == "Y":
+        variables_Y.append(item)
+
+assert_condition(len(variables_Y) == 2, f"Expected 2 instances of 'Y', found {len(variables_Y)}")
+
+# For each instance, get the item at its position and check it's correct
+for idx, var_item in enumerate(variables_Y):
+    # Get the item at var_item's position
+    item_found = minsky.canvas.getItemAt(var_item.x(), var_item.y())
+    assert_condition(item_found, f"No item found at variable's position for instance {idx}")
+    # Check that the found item matches the expected item
+    assert_condition(minsky.canvas.item().id() == var_item.id(),
+                     f"Item at variable's position does not match expected item for instance {idx}")
+    assert_condition(minsky.canvas.item().name() == "Y",
+                     f"Item at variable's position is not 'Y' for instance {idx}")
 EOF
 
-$here/gui-tk/minsky input.tcl
+python3 input.py
 if [ $? -ne 0 ]; then fail; fi
 
 pass

From 575e9c9a9aab9361c6b08ab84140a210bf97efd4 Mon Sep 17 00:00:00 2001
From: wdednam <wdednam@gmail.com>
Date: Wed, 9 Oct 2024 22:03:06 +0200
Subject: [PATCH 3/6] Reverted test instanceList to TCL due to remote fail

---
 test/00/instanceList.sh | 69 ++++++++++++++++++-----------------------
 1 file changed, 30 insertions(+), 39 deletions(-)

diff --git a/test/00/instanceList.sh b/test/00/instanceList.sh
index d88c2941a..0bf38c652 100644
--- a/test/00/instanceList.sh
+++ b/test/00/instanceList.sh
@@ -27,46 +27,37 @@ pass()
 }
 
 trap "fail" 1 2 3 15
-cat >input.py <<EOF
-import sys
-
-# Add the directory containing pyminsky.so to sys.path
-sys.path.insert(0,'$here')
-
-from pyminsky import minsky
-
-def assert_condition(condition, message=""):
-    if not condition:
-        print(f"Assertion failed: {message}")
-        sys.exit(1)
-# Load the model
-minsky.load('/home/dednaw/minsky/examples/GoodwinLinear02.mky')
-
-# Get the number of items in the model
-item_count = len(minsky.model.items)
-
-# Find all variables named "Y"
-variables_Y = []
-for idx in range(item_count):
-    item = minsky.model.items[idx]
-    if item.classType().startswith("Variable:") and item.name() == "Y":
-        variables_Y.append(item)
-
-assert_condition(len(variables_Y) == 2, f"Expected 2 instances of 'Y', found {len(variables_Y)}")
-
-# For each instance, get the item at its position and check it's correct
-for idx, var_item in enumerate(variables_Y):
-    # Get the item at var_item's position
-    item_found = minsky.canvas.getItemAt(var_item.x(), var_item.y())
-    assert_condition(item_found, f"No item found at variable's position for instance {idx}")
-    # Check that the found item matches the expected item
-    assert_condition(minsky.canvas.item().id() == var_item.id(),
-                     f"Item at variable's position does not match expected item for instance {idx}")
-    assert_condition(minsky.canvas.item().name() == "Y",
-                     f"Item at variable's position is not 'Y' for instance {idx}")
+cat >input.tcl <<EOF
+source $here/test/assert.tcl
+minsky.load $here/examples/GoodwinLinear02.mky
+minsky.findVariable "Y"
+set instanceList [minsky.listAllInstances]
+assert "[llength [\$instanceList.names]]==2"
+set offsx [minsky.model.x]
+set offsy [minsky.model.y]
+\$instanceList.gotoInstance 0
+set offsx0 [minsky.model.x]
+set offsy0 [minsky.model.y]
+assert "\$offsx0!=\$offsx"
+assert "\$offsy0!=\$offsy"
+
+
+# offsets hard coded in VariableInstanceList
+minsky.canvas.getItemAt [expr \$offsx-[minsky.model.x]+50] [expr \$offsy-[minsky.model.y]+50]
+assert {[minsky.canvas.item.name]=="Y"}
+
+\$instanceList.gotoInstance 1
+assert "[minsky.model.x]!=\$offsx0"
+assert "[minsky.model.y]!=\$offsy0"
+
+minsky.canvas.getItemAt [expr \$offsx-[minsky.model.x]+50] [expr \$offsy-[minsky.model.y]+50]
+assert {[minsky.canvas.item.name]=="Y"}
+
+assert "[catch \$instanceList.gotoInstance 2]"
+tcl_exit
 EOF
 
-python3 input.py
+$here/gui-tk/minsky input.tcl
 if [ $? -ne 0 ]; then fail; fi
 
-pass
+pass
\ No newline at end of file

From 6dec7ad5177300fc611a251e5d0effe3b06bf3aa Mon Sep 17 00:00:00 2001
From: wdednam <wdednam@gmail.com>
Date: Wed, 9 Oct 2024 22:09:48 +0200
Subject: [PATCH 4/6] Reverted gitignore to upstream version

---
 .gitignore | 34 +---------------------------------
 1 file changed, 1 insertion(+), 33 deletions(-)

diff --git a/.gitignore b/.gitignore
index ca742241c..f08b356a1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -40,36 +40,4 @@ gui-js/documentation/*
 gui-js/dist/*
 gui-js/.nx/*
 gui-js/.angular/*
-doc/minsky/*
-
-# Ignore build artifacts and temporary files
-# Object files, static and shared libraries, executables
-*.o
-*.a
-*.so
-*.dll
-*.exe
-*.gch
-*.node
-
-# Build directories
-/build/
-/bin/
-/obj/
-
-# Logs and temporary files
-*.log
-*.tmp
-*.pid
-*.swp
-*.swo
-
-# Core dumps
-core
-
-# Exclude specific large files
-/gui-js/node-addons/minskyRESTService.node
-/model/minsky.gch
-/libminsky.a
-/st1QD5JV
-
+doc/minsky/*
\ No newline at end of file

From 84c760f8322c136071bea8039ac63503771a52c6 Mon Sep 17 00:00:00 2001
From: wdednam <wdednam@gmail.com>
Date: Thu, 10 Oct 2024 16:31:15 +0200
Subject: [PATCH 5/6] Tricky python refactoring of canvasContext.sh

---
 test/00/canvasContext.sh | 151 +++++++++++++++++++++++----------------
 1 file changed, 90 insertions(+), 61 deletions(-)

diff --git a/test/00/canvasContext.sh b/test/00/canvasContext.sh
index 540b73d9d..51e9a3454 100755
--- a/test/00/canvasContext.sh
+++ b/test/00/canvasContext.sh
@@ -6,72 +6,101 @@ here=`pwd`
 # needs to be a jest test!
 cat >input.py <<EOF
 import sys
-
-sys.path.insert(0,'$here')
-
+sys.path.insert(0, '$here')
 from pyminsky import minsky
 
-def assert_condition(condition, message=""):
-    if not condition:
-        print(f"Assertion failed: {message}")
-        sys.exit(1)
-
-# Clear the model
+# Clear the canvas to start with a clean slate
 minsky.model.clear()
 
-# List of items to test
-items_to_test = [
-    ('Variable', 'foo', 'flow', 'Variable:flow'),
-    ('Operation', 'integrate', None, 'IntOp'),
-    ('Operation', 'data', None, 'DataOp'),
-    ('Plot', None, None, 'PlotWidget'),
-    ('Godley', None, None, 'GodleyIcon'),
-    ('Group', None, None, 'Group'),
-    ('Note', 'hello', None, 'Item'),
-    ('Switch', None, None, 'SwitchIcon'),
-]
-
-# Keep track of added items for verification
-added_items = []
-
-for item_type, name, var_type, expected_class in items_to_test:
-    # Add the item
-    if item_type == 'Variable':
-        minsky.canvas.addVariable(name, var_type)
-    elif item_type == 'Operation':
-        minsky.canvas.addOperation(name)
-    elif item_type == 'Plot':
-        minsky.canvas.addPlot()
-    elif item_type == 'Godley':
-        minsky.canvas.addGodley()
-    elif item_type == 'Group':
-        minsky.canvas.addGroup()
-    elif item_type == 'Note':
-        minsky.canvas.addNote(name)
-    elif item_type == 'Switch':
-        minsky.canvas.addSwitch()
-    else:
-        print(f"Unknown item type: {item_type}")
-        sys.exit(1)
+# Step 1: Check the canvas background context menu
+def canvasContextBackground(x, y, X, Y):
+    # First, check if any item exists at (x, y)
+    item = minsky.canvas.getItemAt(x, y)
+    
+    if item is not None:
+        item = minsky.canvas.itemFocus()
+        if item is not None:
+            minsky.canvas.deleteItem()
+        else:
+            pass
     
-    # The newly added item should be the item in focus
-    item = minsky.canvas.itemFocus()
-    assert_condition(item is not None, f"{item_type} not added correctly")
-    assert_condition(item.classType() == expected_class,
-                     f"{item_type} class type mismatch: expected {expected_class}, got {item.classType()}")
-    # Store the item for further checks
-    added_items.append(item)
-
-# Verify that added items are present in the model
-# Get the number of items in the model
-item_count = len(minsky.model.items)
-
-# Collect IDs of items in model
-model_item_ids = [minsky.model.items[idx].id() for idx in range(item_count)]
-
-# Verify that all added items are in the model
-for item in added_items:
-    assert_condition(item.id() in model_item_ids, f"Item with ID {item.id()} not found in model items")
+    # Verify the item has been fully removed
+    item = minsky.canvas.getItemAt(x, y)
+    if item is not None:
+        item = minsky.canvas.itemFocus()
+        if item is not None:
+            assert not item.classType().startswith("Variable"), "Canvas should not have an interactive item selected on background right-click."
+            minsky.canvas.deleteItem()
+
+# Step 2: Simulate background context click
+canvasContextBackground(0, 0, 0, 0)
+
+# Step 3: Add and test variable context menu
+minsky.canvas.addVariable('foo', 'flow')
+item = minsky.canvas.itemFocus()
+
+# Move the variable to a visible and accessible position (50, 50)
+item.moveTo(50, 50)
+x, y = item.x(), item.y()
+
+# Check context menu on the variable
+def canvasContextOnItem(x, y, X, Y):
+    # Try to get the item at these coordinates
+    assert minsky.canvas.getItemAt(x, y), "Item not found at expected position."
+    item = minsky.canvas.itemFocus()  # Use itemFocus to get the currently focused item
+    assert item is not None, "An item should be selected when right-clicking on it."
+    minsky.canvas.deleteItem()
+
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 4: Add and test operation context menu
+minsky.canvas.addOperation('integrate')
+item = minsky.canvas.itemFocus()
+item.moveTo(100, 100)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 5: Add and test data operation context menu
+minsky.canvas.addOperation('data')
+item = minsky.canvas.itemFocus()
+item.moveTo(150, 150)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 6: Add and test plot context menu
+minsky.canvas.addPlot()
+item = minsky.canvas.itemFocus()
+item.moveTo(200, 200)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 7: Add and test Godley table context menu
+minsky.canvas.addGodley()
+item = minsky.canvas.itemFocus()
+item.moveTo(250, 250)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 8: Add and test group context menu
+minsky.canvas.addGroup()
+item = minsky.canvas.itemFocus()
+item.moveTo(300, 300)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 9: Add and test note context menu
+minsky.canvas.addNote("hello")
+item = minsky.canvas.itemFocus()
+item.moveTo(350, 350)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 10: Add and test switch context menu
+minsky.canvas.addSwitch()
+item = minsky.canvas.itemFocus()
+item.moveTo(400, 400)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
 EOF
 
 python3 input.py

From b5f62bd8e45d6956cf90e77e7c8d5afc7a17df0b Mon Sep 17 00:00:00 2001
From: wdednam <wdednam@gmail.com>
Date: Fri, 11 Oct 2024 12:42:50 +0200
Subject: [PATCH 6/6] Reverted canvasContext to TCL and added new pythonised
 canvasAddMoveItems test

---
 test/00/canvasAddMoveItems.sh | 109 ++++++++++++++++++++++
 test/00/canvasContext.sh      | 168 ++++++++++++++--------------------
 2 files changed, 178 insertions(+), 99 deletions(-)
 create mode 100755 test/00/canvasAddMoveItems.sh

diff --git a/test/00/canvasAddMoveItems.sh b/test/00/canvasAddMoveItems.sh
new file mode 100755
index 000000000..51e9a3454
--- /dev/null
+++ b/test/00/canvasAddMoveItems.sh
@@ -0,0 +1,109 @@
+#! /bin/sh
+
+here=`pwd`
+. $here/test/common-test.sh
+
+# needs to be a jest test!
+cat >input.py <<EOF
+import sys
+sys.path.insert(0, '$here')
+from pyminsky import minsky
+
+# Clear the canvas to start with a clean slate
+minsky.model.clear()
+
+# Step 1: Check the canvas background context menu
+def canvasContextBackground(x, y, X, Y):
+    # First, check if any item exists at (x, y)
+    item = minsky.canvas.getItemAt(x, y)
+    
+    if item is not None:
+        item = minsky.canvas.itemFocus()
+        if item is not None:
+            minsky.canvas.deleteItem()
+        else:
+            pass
+    
+    # Verify the item has been fully removed
+    item = minsky.canvas.getItemAt(x, y)
+    if item is not None:
+        item = minsky.canvas.itemFocus()
+        if item is not None:
+            assert not item.classType().startswith("Variable"), "Canvas should not have an interactive item selected on background right-click."
+            minsky.canvas.deleteItem()
+
+# Step 2: Simulate background context click
+canvasContextBackground(0, 0, 0, 0)
+
+# Step 3: Add and test variable context menu
+minsky.canvas.addVariable('foo', 'flow')
+item = minsky.canvas.itemFocus()
+
+# Move the variable to a visible and accessible position (50, 50)
+item.moveTo(50, 50)
+x, y = item.x(), item.y()
+
+# Check context menu on the variable
+def canvasContextOnItem(x, y, X, Y):
+    # Try to get the item at these coordinates
+    assert minsky.canvas.getItemAt(x, y), "Item not found at expected position."
+    item = minsky.canvas.itemFocus()  # Use itemFocus to get the currently focused item
+    assert item is not None, "An item should be selected when right-clicking on it."
+    minsky.canvas.deleteItem()
+
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 4: Add and test operation context menu
+minsky.canvas.addOperation('integrate')
+item = minsky.canvas.itemFocus()
+item.moveTo(100, 100)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 5: Add and test data operation context menu
+minsky.canvas.addOperation('data')
+item = minsky.canvas.itemFocus()
+item.moveTo(150, 150)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 6: Add and test plot context menu
+minsky.canvas.addPlot()
+item = minsky.canvas.itemFocus()
+item.moveTo(200, 200)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 7: Add and test Godley table context menu
+minsky.canvas.addGodley()
+item = minsky.canvas.itemFocus()
+item.moveTo(250, 250)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 8: Add and test group context menu
+minsky.canvas.addGroup()
+item = minsky.canvas.itemFocus()
+item.moveTo(300, 300)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 9: Add and test note context menu
+minsky.canvas.addNote("hello")
+item = minsky.canvas.itemFocus()
+item.moveTo(350, 350)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+
+# Step 10: Add and test switch context menu
+minsky.canvas.addSwitch()
+item = minsky.canvas.itemFocus()
+item.moveTo(400, 400)
+x, y = item.x(), item.y()
+canvasContextOnItem(x, y, int(x), int(y))
+EOF
+
+python3 input.py
+if [ $? -ne 0 ]; then fail; fi
+
+pass
diff --git a/test/00/canvasContext.sh b/test/00/canvasContext.sh
index 51e9a3454..c7f38ae00 100755
--- a/test/00/canvasContext.sh
+++ b/test/00/canvasContext.sh
@@ -4,106 +4,76 @@ here=`pwd`
 . $here/test/common-test.sh
 
 # needs to be a jest test!
-cat >input.py <<EOF
-import sys
-sys.path.insert(0, '$here')
-from pyminsky import minsky
-
-# Clear the canvas to start with a clean slate
-minsky.model.clear()
-
-# Step 1: Check the canvas background context menu
-def canvasContextBackground(x, y, X, Y):
-    # First, check if any item exists at (x, y)
-    item = minsky.canvas.getItemAt(x, y)
-    
-    if item is not None:
-        item = minsky.canvas.itemFocus()
-        if item is not None:
-            minsky.canvas.deleteItem()
-        else:
-            pass
-    
-    # Verify the item has been fully removed
-    item = minsky.canvas.getItemAt(x, y)
-    if item is not None:
-        item = minsky.canvas.itemFocus()
-        if item is not None:
-            assert not item.classType().startswith("Variable"), "Canvas should not have an interactive item selected on background right-click."
-            minsky.canvas.deleteItem()
-
-# Step 2: Simulate background context click
-canvasContextBackground(0, 0, 0, 0)
-
-# Step 3: Add and test variable context menu
-minsky.canvas.addVariable('foo', 'flow')
-item = minsky.canvas.itemFocus()
-
-# Move the variable to a visible and accessible position (50, 50)
-item.moveTo(50, 50)
-x, y = item.x(), item.y()
-
-# Check context menu on the variable
-def canvasContextOnItem(x, y, X, Y):
-    # Try to get the item at these coordinates
-    assert minsky.canvas.getItemAt(x, y), "Item not found at expected position."
-    item = minsky.canvas.itemFocus()  # Use itemFocus to get the currently focused item
-    assert item is not None, "An item should be selected when right-clicking on it."
-    minsky.canvas.deleteItem()
-
-canvasContextOnItem(x, y, int(x), int(y))
-
-# Step 4: Add and test operation context menu
-minsky.canvas.addOperation('integrate')
-item = minsky.canvas.itemFocus()
-item.moveTo(100, 100)
-x, y = item.x(), item.y()
-canvasContextOnItem(x, y, int(x), int(y))
-
-# Step 5: Add and test data operation context menu
-minsky.canvas.addOperation('data')
-item = minsky.canvas.itemFocus()
-item.moveTo(150, 150)
-x, y = item.x(), item.y()
-canvasContextOnItem(x, y, int(x), int(y))
-
-# Step 6: Add and test plot context menu
-minsky.canvas.addPlot()
-item = minsky.canvas.itemFocus()
-item.moveTo(200, 200)
-x, y = item.x(), item.y()
-canvasContextOnItem(x, y, int(x), int(y))
-
-# Step 7: Add and test Godley table context menu
-minsky.canvas.addGodley()
-item = minsky.canvas.itemFocus()
-item.moveTo(250, 250)
-x, y = item.x(), item.y()
-canvasContextOnItem(x, y, int(x), int(y))
-
-# Step 8: Add and test group context menu
-minsky.canvas.addGroup()
-item = minsky.canvas.itemFocus()
-item.moveTo(300, 300)
-x, y = item.x(), item.y()
-canvasContextOnItem(x, y, int(x), int(y))
-
-# Step 9: Add and test note context menu
-minsky.canvas.addNote("hello")
-item = minsky.canvas.itemFocus()
-item.moveTo(350, 350)
-x, y = item.x(), item.y()
-canvasContextOnItem(x, y, int(x), int(y))
-
-# Step 10: Add and test switch context menu
-minsky.canvas.addSwitch()
-item = minsky.canvas.itemFocus()
-item.moveTo(400, 400)
-x, y = item.x(), item.y()
-canvasContextOnItem(x, y, int(x), int(y))
+cat >input.tcl <<EOF
+source $here/test/assert.tcl
+proc afterMinskyStarted {} {
+  canvasContext 0 0 0 0
+  assert {[winfo ismapped .wiring.context]}
+  .wiring.context unpost
+
+  assert {![winfo ismapped .wiring.context]}
+  wireContextMenu 0 0
+  assert {[winfo ismapped .wiring.context]}
+   .wiring.context unpost
+
+  # need to check context on all types of items
+  minsky.addVariable foo flow
+  assert {[findObject Variable:flow]}
+  contextMenu 0 0 0 0
+  assert {[winfo ismapped .wiring.context]} "variable"
+  .wiring.context unpost
+  assert {![winfo ismapped .wiring.context]}
+
+  minsky.addOperation integrate
+  assert {[findObject IntOp]}
+  contextMenu 0 0 0 0
+  assert {[winfo ismapped .wiring.context]} "operation"
+  .wiring.context unpost
+
+  minsky.addOperation data
+  assert {[findObject DataOp]}
+  contextMenu 0 0 0 0
+  assert {[winfo ismapped .wiring.context]} "data operation"
+  .wiring.context unpost
+
+
+
+  minsky.addPlot
+  assert {[findObject PlotWidget]}
+  contextMenu 0 0 0 0
+  assert {[winfo ismapped .wiring.context]} "plot"
+  .wiring.context unpost
+
+  minsky.addGodley
+  assert {[findObject GodleyIcon]}
+  contextMenu 0 0 0 0
+  assert {[winfo ismapped .wiring.context]} "godley"
+  .wiring.context unpost
+
+  minsky.addGroup
+  assert {[findObject Group]}
+  contextMenu 0 0 0 0
+  assert {[winfo ismapped .wiring.context]} "group"
+  .wiring.context unpost
+  
+  minsky.addNote "hello"
+  assert {[findObject Item]}
+  contextMenu 0 0 0 0
+  assert {[winfo ismapped .wiring.context]} "note"
+  .wiring.context unpost
+
+  minsky.addSwitch
+  assert {[findObject SwitchIcon]}
+  contextMenu 0 0 0 0
+  assert {[winfo ismapped .wiring.context]} "switch"
+  .wiring.context unpost
+  
+
+  tcl_exit
+}
 EOF
 
-python3 input.py
+$here/gui-tk/minsky input.tcl
 if [ $? -ne 0 ]; then fail; fi
 
-pass
+pass
\ No newline at end of file