teek-ui 0.1.0

data/test/test_ui.rb

@@ -0,0 +1,428 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+class TestUI < Minitest::Test
+  include TeekTestHelper
+
+  def test_app_yields_and_returns_the_same_session
+    assert_tk_app("Teek::UI.app should yield a session and return that same session") do
+      require 'teek/ui'
+
+      yielded = nil
+      session = Teek::UI.app(title: 'UI Scaffold Test') { |ui| yielded = ui }
+
+      assert_same session, yielded, "the block should receive the same session .app returns"
+      assert_kind_of Teek::UI::Session, session
+    end
+  end
+
+  def test_build_constructs_no_tcl_interpreter
+    assert_tk_app("building a session should not construct any Teek::App/Interp until realize") do
+      require 'teek/ui'
+
+      baseline = Teek::Interp.instance_count
+      Teek::UI.app(title: 'UI Scaffold Test') { |ui| ui.document }
+
+      assert_equal baseline, Teek::Interp.instance_count,
+        "Teek::UI.app should not construct an interpreter before #realize/#run/#run_async"
+    end
+  end
+
+  def test_session_exposes_a_document_before_realize
+    assert_tk_app("session.document should be a real, empty Document, buildable with no interpreter") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'UI Scaffold Test')
+
+      assert_kind_of Teek::UI::Document, session.document
+      assert_equal [], session.document.root.children
+    end
+  end
+
+  def test_session_app_raises_before_realize
+    assert_tk_app("session.app should raise a clear error before realize") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'UI Scaffold Test')
+
+      error = assert_raises(Teek::UI::NotRealizedError) { session.app }
+      assert_match(/not realized/i, error.message)
+    end
+  end
+
+  def test_session_every_and_after_queue_before_realize_and_fire_once_realized
+    assert_tk_app("session.every/.after declared inside the build block should queue (no NotRealizedError) and actually fire once realized") do
+      require 'teek/ui'
+
+      ticks = 0
+      fired = false
+      session = Teek::UI.app(title: 'Timers Test') do |ui|
+        ui.every(10) { ticks += 1 }
+        ui.after(10) { fired = true }
+      end
+      session.run_async
+
+      deadline = Time.now + 2
+      session.app.update until (ticks >= 2 && fired) || Time.now > deadline
+
+      assert_operator ticks, :>=, 2, "a build-block ui.every should have ticked after realize, same as a post-realize one"
+      assert fired, "a build-block ui.after should have fired after realize, same as a post-realize one"
+
+      session.app.destroy
+    end
+  end
+
+  def test_a_build_block_timer_and_a_post_realize_timer_behave_identically
+    assert_tk_app("a timer declared inside the build block and one declared after realize should produce the same runtime behavior") do
+      require 'teek/ui'
+
+      queued_ticks = 0
+      session = Teek::UI.app(title: 'Timers Test') { |ui| ui.every(10) { queued_ticks += 1 } }
+      session.run_async
+
+      post_realize_ticks = 0
+      session.every(10) { post_realize_ticks += 1 }
+
+      deadline = Time.now + 2
+      session.app.update until (queued_ticks >= 2 && post_realize_ticks >= 2) || Time.now > deadline
+
+      assert_operator queued_ticks, :>=, 2
+      assert_operator post_realize_ticks, :>=, 2
+
+      session.app.destroy
+    end
+  end
+
+  def test_session_every_returns_nil_when_queued_before_realize
+    assert_tk_app("session.every should return nil when queued (no live timer object exists yet to hand back)") do
+      require 'teek/ui'
+
+      result = nil
+      session = Teek::UI.app(title: 'Timers Test') { |ui| result = ui.every(10) { } }
+      session.run_async
+      session.app.update
+
+      assert_nil result
+
+      session.app.destroy
+    end
+  end
+
+  def test_realize_creates_the_app_exactly_once
+    assert_tk_app("realize should create the app once and return the same app on repeat calls") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'UI Scaffold Test')
+      baseline = Teek::Interp.instance_count
+
+      app1 = session.realize
+      app2 = session.realize
+
+      assert_same app1, app2, "realize should be idempotent, not build a second interpreter"
+      assert_equal baseline + 1, Teek::Interp.instance_count
+
+      session.app.destroy
+    end
+  end
+
+  def test_session_app_after_realize_reflects_the_title
+    assert_tk_app("session.app after realize should expose the real Teek::App with the title applied") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'UI Scaffold Test')
+      session.realize
+
+      assert_kind_of Teek::App, session.app
+      assert_equal 'UI Scaffold Test', session.app.wm.title(window: '.')
+
+      session.app.destroy
+    end
+  end
+
+  def test_run_async_realizes_shows_the_window_and_returns_without_blocking
+    assert_tk_app("run_async should realize, show the window, and return the session without entering mainloop") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Run Async Test')
+      result = session.run_async
+
+      assert_same session, result
+
+      # run_async deliberately doesn't pump the event loop itself (that's the
+      # documented caveat) - the deiconify it issued only becomes visible to
+      # winfo after something processes events, same as a real caller would
+      # need to do between REPL statements.
+      session.app.update
+      assert session.app.winfo.ismapped?('.'), "run_async should have shown the root window"
+
+      session.app.destroy
+    end
+  end
+
+  def test_every_delegates_to_the_underlying_app_after_realize
+    assert_tk_app("ui.every should delegate to App#every and actually tick, once realized") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Timers Test')
+      session.run_async
+      ticks = 0
+      timer = session.every(10) { ticks += 1 }
+
+      deadline = Time.now + 2
+      session.app.update until ticks >= 2 || Time.now > deadline
+
+      assert_operator ticks, :>=, 2, "ui.every's block did not tick"
+      timer.cancel
+      session.app.destroy
+    end
+  end
+
+  def test_after_delegates_to_the_underlying_app_after_realize
+    assert_tk_app("ui.after should delegate to App#after, once realized") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Timers Test')
+      session.run_async
+      fired = false
+      session.after(10) { fired = true }
+
+      deadline = Time.now + 2
+      session.app.update until fired || Time.now > deadline
+
+      assert fired, "ui.after's block did not fire"
+      session.app.destroy
+    end
+  end
+
+  def test_dialog_methods_raise_before_realize
+    assert_tk_app("session's dialog methods should raise a clear error before realize, not queue") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Dialogs Test')
+
+      assert_raises(Teek::UI::NotRealizedError) { session.open_file }
+      assert_raises(Teek::UI::NotRealizedError) { session.save_file }
+      assert_raises(Teek::UI::NotRealizedError) { session.message(message: 'Hi') }
+      assert_raises(Teek::UI::NotRealizedError) { session.choose_color }
+      assert_raises(Teek::UI::NotRealizedError) { session.choose_dir }
+    end
+  end
+
+  def test_open_file_forwards_every_option_under_its_real_tk_flag_name
+    assert_tk_app("session.open_file should forward every option to App#choose_open_file under the right flag") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Dialogs Test')
+      session.run_async
+      session.app.tcl_eval(<<~TCL)
+        proc tk_getOpenFile {args} {
+          set ::last_call $args
+          return {/tmp/picked.png}
+        }
+      TCL
+
+      result = session.open_file(
+        initialdir: '/tmp/open', initialfile: 'pick.png', title: 'Open It', multiple: true, parent: '.mywin'
+      )
+
+      assert_equal ['/tmp/picked.png'], result, "multiple: true should split Tk's result into an array"
+      captured = Hash[*session.app.split_list(session.app.tcl_eval('set ::last_call'))]
+      assert_equal(
+        { '-initialdir' => '/tmp/open', '-initialfile' => 'pick.png', '-title' => 'Open It',
+          '-parent' => '.mywin', '-multiple' => '1' },
+        captured
+      )
+
+      session.app.destroy
+    end
+  end
+
+  def test_save_file_forwards_every_option_under_its_real_tk_flag_name
+    assert_tk_app("session.save_file should forward every option to App#choose_save_file under the right flag") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Dialogs Test')
+      session.run_async
+      session.app.tcl_eval(<<~TCL)
+        proc tk_getSaveFile {args} {
+          set ::last_call $args
+          return {/tmp/out.png}
+        }
+      TCL
+
+      result = session.save_file(
+        initialdir: '/tmp/save', initialfile: 'out.png', title: 'Save It',
+        defaultextension: '.png', confirmoverwrite: false, parent: '.mywin'
+      )
+
+      assert_equal '/tmp/out.png', result
+      captured = Hash[*session.app.split_list(session.app.tcl_eval('set ::last_call'))]
+      assert_equal(
+        { '-initialdir' => '/tmp/save', '-initialfile' => 'out.png', '-title' => 'Save It',
+          '-defaultextension' => '.png', '-confirmoverwrite' => '0', '-parent' => '.mywin' },
+        captured
+      )
+
+      session.app.destroy
+    end
+  end
+
+  def test_message_forwards_every_option_under_its_real_tk_flag_name
+    assert_tk_app("session.message should forward every option to App#message_box under the right flag") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Dialogs Test')
+      session.run_async
+      session.app.tcl_eval(<<~TCL)
+        proc tk_messageBox {args} {
+          set ::last_call $args
+          return {yes}
+        }
+      TCL
+
+      result = session.message(
+        message: 'Sure?', title: 'Confirm', detail: 'Cannot be undone',
+        icon: :warning, type: :yesno, default: :no, parent: '.mywin'
+      )
+
+      assert_equal :yes, result
+      captured = Hash[*session.app.split_list(session.app.tcl_eval('set ::last_call'))]
+      assert_equal(
+        { '-message' => 'Sure?', '-title' => 'Confirm', '-detail' => 'Cannot be undone',
+          '-icon' => 'warning', '-type' => 'yesno', '-default' => 'no', '-parent' => '.mywin' },
+        captured
+      )
+
+      session.app.destroy
+    end
+  end
+
+  def test_choose_color_forwards_every_option_under_its_real_tk_flag_name
+    assert_tk_app("session.choose_color should forward every option to App#choose_color under the right flag") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Dialogs Test')
+      session.run_async
+      session.app.tcl_eval(<<~TCL)
+        proc tk_chooseColor {args} {
+          set ::last_call $args
+          return {#ff0080}
+        }
+      TCL
+
+      result = session.choose_color(initial: '#112233', title: 'Pick', parent: '.mywin')
+
+      assert_equal '#ff0080', result
+      captured = Hash[*session.app.split_list(session.app.tcl_eval('set ::last_call'))]
+      assert_equal({ '-initialcolor' => '#112233', '-title' => 'Pick', '-parent' => '.mywin' }, captured)
+
+      session.app.destroy
+    end
+  end
+
+  def test_choose_dir_forwards_every_option_under_its_real_tk_flag_name
+    assert_tk_app("session.choose_dir should forward every option to App#choose_dir under the right flag") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Dialogs Test')
+      session.run_async
+      session.app.tcl_eval(<<~TCL)
+        proc tk_chooseDirectory {args} {
+          set ::last_call $args
+          return {/tmp/some dir}
+        }
+      TCL
+
+      result = session.choose_dir(initialdir: '/tmp/dir', mustexist: true, title: 'Folder', parent: '.mywin')
+
+      assert_equal '/tmp/some dir', result
+      captured = Hash[*session.app.split_list(session.app.tcl_eval('set ::last_call'))]
+      assert_equal(
+        { '-initialdir' => '/tmp/dir', '-mustexist' => '1', '-title' => 'Folder', '-parent' => '.mywin' },
+        captured
+      )
+
+      session.app.destroy
+    end
+  end
+
+  def test_realize_validates_before_constructing_any_interpreter
+    assert_tk_app("a validation failure should prevent any Teek::App/Interp from being constructed at all") do
+      require 'teek/ui'
+
+      baseline = Teek::Interp.instance_count
+      session = Teek::UI.app(title: 'Validation Test') do |ui|
+        ui.grid(:g) do |g|
+          g.cell(row: 0, col: 0) { g.label(:a, text: 'A') }
+          g.cell(row: 0, col: 0) { g.label(:b, text: 'B') }
+        end
+      end
+
+      error = assert_raises(Teek::UI::ValidationError) { session.realize }
+      assert_match(/row 0, col 0/, error.message)
+
+      assert_equal baseline, Teek::Interp.instance_count,
+        "a doomed build should never construct an interpreter, not even one that gets destroyed afterward"
+      assert_raises(Teek::UI::NotRealizedError) { session.app }
+    end
+  end
+
+  def test_build_methods_raise_once_the_session_has_realized
+    assert_tk_app("ui.button/panel/raw/var/menu_bar/context_menu should all raise once the build has closed") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Closed Builder Test')
+      session.run_async
+
+      error = assert_raises(Teek::UI::ClosedBuilderError) { session.button(:late, text: 'Too late') }
+      assert_match(/session\.add/, error.message)
+
+      assert_raises(Teek::UI::ClosedBuilderError) { session.panel(:late) }
+      assert_raises(Teek::UI::ClosedBuilderError) { session.raw { } }
+      assert_raises(Teek::UI::ClosedBuilderError) { session.var(1) }
+      assert_raises(Teek::UI::ClosedBuilderError) { session.menu_bar }
+      assert_raises(Teek::UI::ClosedBuilderError) { session.context_menu }
+
+      session.app.destroy
+    end
+  end
+
+  def test_build_methods_still_work_normally_before_realize
+    assert_tk_app("the closed-builder guard should never fire during the ordinary, still-open initial build") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Closed Builder Test') do |ui|
+        ui.button(:go, text: 'Go')
+        ui.var(1)
+      end
+      session.run_async
+      session.app.update
+
+      assert session.app.winfo.ismapped?(session[:go].path)
+
+      session.app.destroy
+    end
+  end
+
+  def test_session_add_re_opens_the_builder_for_the_duration_of_its_own_block
+    assert_tk_app("session.add's own block should be exempt from the closed-builder guard") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Closed Builder Test') { |ui| ui.column(:list) }
+      session.run_async
+
+      session.add(:list) { |a| a.button(:added, text: 'Added') }
+      session.app.update
+
+      assert session.app.winfo.ismapped?(session[:added].path)
+
+      # the guard should still apply to code OUTSIDE session.add, even
+      # though it's fine again momentarily while add's own block runs
+      assert_raises(Teek::UI::ClosedBuilderError) { session.button(:still_too_late, text: 'Nope') }
+
+      session.app.destroy
+    end
+  end
+end

data/test/test_validator.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+require 'teek/ui/session'
+require 'teek/ui/validator'
+
+class TestValidator < Minitest::Test
+  def build_session
+    Teek::UI::Session.new(title: 'Validator Test')
+  end
+
+  def test_a_clean_tree_passes_without_raising_or_warning
+    session = build_session
+    session.column(:controls) { |c| c.button(:go, text: 'Go') }
+
+    out, err = capture_io { Teek::UI::Validator.validate!(session.document) }
+
+    assert_empty out
+    assert_empty err
+  end
+
+  def test_stray_cell_intent_under_a_non_grid_parent_raises
+    # only reachable via direct Node/Document manipulation - g.cell itself
+    # already refuses to run outside a ui.grid block, so the public DSL
+    # can never actually produce this.
+    document = Teek::UI::Document.new
+    panel = document.create(type: :panel, name: :not_a_grid)
+    document.root.add_child(panel)
+    stray = document.create(type: :label, name: :stray)
+    stray.layout = { cell: { row: 0, col: 0, span: 1 } }
+    panel.add_child(stray)
+
+    error = assert_raises(Teek::UI::ValidationError) { Teek::UI::Validator.validate!(document) }
+    assert_match(/stray/, error.message)
+    assert_match(/not_a_grid/, error.message)
+  end
+
+  def test_stray_overlay_intent_under_a_non_canvas_parent_raises
+    # only reachable via direct Node/Document manipulation - WidgetDSL#overlay
+    # itself already refuses to run outside a ui.canvas block.
+    document = Teek::UI::Document.new
+    panel = document.create(type: :panel, name: :not_a_canvas)
+    document.root.add_child(panel)
+    stray = document.create(type: :label, name: :stray)
+    stray.layout = { overlay: { at: :top_left } }
+    panel.add_child(stray)
+
+    error = assert_raises(Teek::UI::ValidationError) { Teek::UI::Validator.validate!(document) }
+    assert_match(/overlay/, error.message)
+    assert_match(/not_a_canvas/, error.message)
+  end
+
+  def test_a_tab_node_under_a_non_tabs_parent_raises
+    # only reachable via direct Node/Document manipulation - WidgetDSL#tab
+    # itself already refuses to run outside a ui.tabs block.
+    document = Teek::UI::Document.new
+    panel = document.create(type: :panel, name: :not_tabs)
+    document.root.add_child(panel)
+    stray = document.create(type: :tab, name: :stray, opts: { tab_label: 'Stray' })
+    panel.add_child(stray)
+
+    error = assert_raises(Teek::UI::ValidationError) { Teek::UI::Validator.validate!(document) }
+    assert_match(/:tab/, error.message)
+    assert_match(/not_tabs/, error.message)
+  end
+
+  def test_a_pane_node_under_a_non_split_parent_raises
+    # only reachable via direct Node/Document manipulation - WidgetDSL#pane
+    # itself already refuses to run outside a ui.split block.
+    document = Teek::UI::Document.new
+    panel = document.create(type: :panel, name: :not_split)
+    document.root.add_child(panel)
+    stray = document.create(type: :pane, name: :stray)
+    panel.add_child(stray)
+
+    error = assert_raises(Teek::UI::ValidationError) { Teek::UI::Validator.validate!(document) }
+    assert_match(/:pane/, error.message)
+    assert_match(/not_split/, error.message)
+  end
+
+  def test_two_widgets_in_the_same_grid_cell_raises
+    session = build_session
+    session.grid(:g) do |g|
+      g.cell(row: 0, col: 0) { g.label(:a, text: 'A') }
+      g.cell(row: 0, col: 0) { g.label(:b, text: 'B') }
+    end
+
+    error = assert_raises(Teek::UI::ValidationError) { Teek::UI::Validator.validate!(session.document) }
+    assert_match(/row 0, col 0/, error.message)
+    assert_match(/:a\b/, error.message)
+    assert_match(/:b\b/, error.message)
+  end
+
+  def test_different_grid_cells_do_not_raise
+    session = build_session
+    session.grid(:g) do |g|
+      g.cell(row: 0, col: 0) { g.label(:a, text: 'A') }
+      g.cell(row: 0, col: 1) { g.label(:b, text: 'B') }
+    end
+
+    capture_io { Teek::UI::Validator.validate!(session.document) }
+  end
+
+  def test_a_grid_child_missing_a_cell_raises
+    # only reachable via direct Node/Document manipulation for a label
+    # specifically (the DSL's own ui.grid { |g| g.label(...) } would need
+    # g.cell to place it at all) - constructed directly here so the check
+    # is exercised in isolation from #test_a_widget_placed_directly_in_a_grid_without_cell_is_caught_by_validation's
+    # real-Tk, full-session version.
+    document = Teek::UI::Document.new
+    grid = document.create(type: :grid, name: :g)
+    document.root.add_child(grid)
+    oops = document.create(type: :label, name: :oops)
+    grid.add_child(oops)
+
+    error = assert_raises(Teek::UI::ValidationError) { Teek::UI::Validator.validate!(document) }
+    assert_match(/cell/i, error.message)
+    assert_match(/oops/, error.message)
+  end
+
+  def test_raw_op_and_other_not_grid_arranged_types_inside_a_grid_do_not_need_a_cell
+    session = build_session
+    session.grid(:g) { |g| g.raw { |_app| } }
+
+    capture_io { Teek::UI::Validator.validate!(session.document) }
+  end
+
+  def test_both_grid_misuse_directions_can_be_reported_together
+    document = Teek::UI::Document.new
+    grid = document.create(type: :grid, name: :g)
+    document.root.add_child(grid)
+    missing_cell = document.create(type: :label, name: :missing_cell)
+    grid.add_child(missing_cell)
+    panel = document.create(type: :panel, name: :not_a_grid)
+    document.root.add_child(panel)
+    stray = document.create(type: :label, name: :stray)
+    stray.layout = { cell: { row: 0, col: 0, span: 1 } }
+    panel.add_child(stray)
+
+    error = assert_raises(Teek::UI::ValidationError) { Teek::UI::Validator.validate!(document) }
+    assert_match(/missing_cell/, error.message)
+    assert_match(/stray/, error.message)
+  end
+
+  def test_dangling_event_target_raises_naming_both_ends
+    # on_click et al never expose target: through the public Handle API
+    # (it's an internal mechanism for future forward-reference features),
+    # so this is only reachable via direct EventBinding construction too.
+    session = build_session
+    session.button(:trigger, text: 'Go')
+    session.document.find(:trigger).events <<
+      Teek::UI::EventBinding.new(event: '<Button-1>', handler: -> { }, target: :nope)
+
+    error = assert_raises(Teek::UI::ValidationError) { Teek::UI::Validator.validate!(session.document) }
+    assert_match(/trigger/, error.message)
+    assert_match(/nope/, error.message)
+  end
+
+  def test_event_target_naming_a_different_components_node_is_reported_as_dangling_not_silently_matched
+    # a :downstream exists in the document - just not in the trigger's OWN
+    # scope, so flat resolution would silently find the WRONG one; scoped
+    # resolution should report this exactly like a genuinely nonexistent
+    # target, not silently match across the component boundary.
+    session = build_session
+    session.component { |c| c.label(:downstream, text: 'Elsewhere') }
+    session.component { |c| c.button(:trigger, text: 'Go') }
+
+    _elsewhere_downstream, trigger_node = session.document.root.children
+    trigger_node.events <<
+      Teek::UI::EventBinding.new(event: '<Button-1>', handler: -> { }, target: :downstream)
+
+    error = assert_raises(Teek::UI::ValidationError) { Teek::UI::Validator.validate!(session.document) }
+    assert_match(/trigger/, error.message)
+    assert_match(/downstream/, error.message)
+  end
+
+  def test_orphan_named_node_warns_by_default
+    document = Teek::UI::Document.new
+    document.create(type: :button, name: :lost) # never attached to any parent
+
+    out, err = capture_io { Teek::UI::Validator.validate!(document) }
+
+    assert_empty out
+    assert_match(/lost/, err)
+  end
+
+  def test_orphan_named_node_raises_under_strict_mode
+    document = Teek::UI::Document.new
+    document.create(type: :button, name: :lost)
+
+    error = assert_raises(Teek::UI::ValidationError) { Teek::UI::Validator.validate!(document, strict: true) }
+    assert_match(/lost/, error.message)
+  end
+
+  def test_multiple_problems_all_appear_in_one_raised_error
+    session = build_session
+    session.grid(:g) do |g|
+      g.cell(row: 0, col: 0) { g.label(:a, text: 'A') }
+      g.cell(row: 0, col: 0) { g.label(:b, text: 'B') }
+    end
+    session.button(:trigger, text: 'Go')
+    session.document.find(:trigger).events <<
+      Teek::UI::EventBinding.new(event: '<Button-1>', handler: -> { }, target: :nope)
+
+    error = assert_raises(Teek::UI::ValidationError) { Teek::UI::Validator.validate!(session.document) }
+    assert_match(/row 0, col 0/, error.message)
+    assert_match(/nope/, error.message)
+  end
+end

data/test/test_var.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+require 'teek/ui/var'
+
+class TestVar < Minitest::Test
+  def test_name_is_the_allocated_tcl_variable_name
+    var = Teek::UI::Var.new('::teek_ui_var_1', 5)
+
+    assert_equal '::teek_ui_var_1', var.name
+  end
+
+  def test_value_raises_before_realize
+    var = Teek::UI::Var.new('::teek_ui_var_1', 5)
+
+    assert_raises(Teek::UI::NotRealizedError) { var.value }
+  end
+
+  def test_value_assignment_raises_before_realize
+    var = Teek::UI::Var.new('::teek_ui_var_1', 5)
+
+    assert_raises(Teek::UI::NotRealizedError) { var.value = 6 }
+  end
+
+  def test_on_change_is_queueable_before_realize_and_returns_self
+    var = Teek::UI::Var.new('::teek_ui_var_1', 5)
+
+    result = var.on_change { |v| v }
+
+    assert_same var, result
+  end
+end