redcar-dev 0.12.17dev

data/plugins/application/features/step_definitions/command_steps.rb

@@ -0,0 +1,10 @@
+
+When /^I run the command ([^\s]+)$/ do |command_name|
+  command_class = eval(command_name)
+  command = command_class.new
+  if command.is_a?(Redcar::DocumentCommand)
+    command.run(:env => {:edit_view => implicit_edit_view})
+  else
+    command.run
+  end
+end

data/plugins/application/features/step_definitions/dialog_steps.rb

@@ -0,0 +1,25 @@
+
+Given /^I will choose "([^\"]*)" from the "([^\"]*)" dialog$/ do |path, type|
+  Redcar.gui.dialog_adapter.should_get_message(:any)
+  Redcar.gui.dialog_adapter.set(type.to_sym, path)
+end
+
+Given /^I would type "([^"]*)" in an input box$/ do |params|
+  Redcar.gui.dialog_adapter.add_input(params)
+end
+
+Then /^I should not see a "([^\"]*)" dialog for the rest of the feature/ do |type|
+  Redcar.gui.dialog_adapter.set(type.to_sym, :raise_error)
+end
+
+Then /^I should see a message box containing "([^"]*)"$/ do |arg1|
+  Redcar.gui.dialog_adapter.should_get_message(arg1)
+end
+
+Then /^I should see a popup text box with title "([^"]*)" and containing "([^"]*)"$/ do |title,text|
+  Redcar.gui.dialog_adapter.should_get_popup_message(title,text)
+end
+
+Then /^I should see a popup html box containing "([^"]*)"$/ do |text|
+  Redcar.gui.dialog_adapter.should_get_popup_html(text)
+end

data/plugins/application/features/step_definitions/filter_list_dialog_steps.rb

@@ -0,0 +1,42 @@
+
+def filter_dialog
+  dialog(Redcar::ApplicationSWT::FilterListDialogController::FilterListDialog)
+end
+
+def filter_dialog_items
+  filter_dialog.list.get_items.to_a
+end
+
+Then /^there should be a filter dialog open$/ do
+  filter_dialog.should_not be_nil
+end
+
+Then /^there should be no filter dialog open$/ do
+  filter_dialog.should be_nil
+end
+
+When /^I set the filter to "(.*)"$/ do |text|
+  filter_dialog.text.set_text(text)
+end
+
+When /^I select in the filter dialog$/ do
+  filter_dialog.controller.selected
+end
+
+When /^I wait "(.*)" seconds?$/ do |time|
+  Cucumber::Ast::StepInvocation.wait_time = time.to_f
+end
+
+Then /^the filter dialog should have (no|\d+) entr(?:y|ies)$/ do |num|
+  num = (num == "no" ? 0 : num.to_i)
+  filter_dialog_items.length.should == num
+end
+
+Then /^I should see "(.*)" at (\d+) the filter dialog$/ do |text, pos|
+  pos = pos.to_i
+  filter_dialog_items[pos].should == text
+end
+
+Then /^I should not see "(.*)" in the filter dialog$/ do |text|
+  filter_dialog_items.include?(text).should be_false
+end

data/plugins/application/features/step_definitions/key_steps.rb

@@ -0,0 +1,18 @@
+key_presses = {
+  "ARROW_UP" => "up arrow",
+  "ARROW_DOWN" => "down arrow",
+  "ARROW_LEFT" => "left arrow",
+  "ARROW_RIGHT" => "right arrow",
+  "CR" => "return",
+  "BS" => "backspace",
+  "HOME" => "home",
+  "DEL" => "delete"
+}
+key_presses.each do |const,text|
+  When "I press the #{text} key" do
+    tab = Redcar.app.focussed_window.focussed_notebook_tab
+    widget = tab.edit_view.controller.mate_text.get_control
+    key = Swt::SWT.const_get(const)
+    FakeKeyEvent.new(key,widget)
+  end
+end

data/plugins/application/features/step_definitions/menu_steps.rb

@@ -0,0 +1,42 @@
+
+Then /^there should be a main menu$/ do
+  main_menu.should_not be_nil
+end
+
+Then /^the main menu should contain "([^\"]*)" entries$/ do |entries|
+  entries = entries.split(",").map {|e| e.strip }
+  items = main_menu.get_items.to_a
+  items.should_not be_empty
+  texts = items.map {|item| item.get_text }
+  entries.all? {|e| texts.include?(get_menu_name(e))}.should be_true
+end
+
+Then /^the "([^\"]*)" menu should contain a "([^\"]*)" entry$/ do |menu_text, entry_text|
+  items = main_menu.get_items.to_a
+  menu = items.detect {|i| i.text == get_menu_name(menu_text)}
+  items = menu.get_menu.get_items.to_a
+  menu_texts = items.map{|i| i.text.split("\t").first}
+  menu_texts.detect {|t| t == entry_text}.should_not be_nil
+end
+
+Then /^the menu item "([^\"]*)\|([^\"]*)" should be (active|inactive)$/ do |menu_name, menu_item, active|
+  items = main_menu.get_items.to_a
+  menu = items.detect {|i| i.text == get_menu_name(menu_name)}
+  items = menu.get_menu.get_items.to_a
+  item = items.detect {|i| i.text.split("\t").first == menu_item }
+  case active
+  when "active"
+    item.enabled.should be_true
+  when "inactive"
+    item.enabled.should be_false
+  end
+end
+
+When /^I (?:open the|click) "([^"]*)" from the "([^"]*)" menu$/ do |menu_item, menu_name|
+  menu_items = menu_name.split("/").inject(main_menu.get_items.to_a.dup) do |items, item_name|
+    m = items.detect {|i| i.text == get_menu_name(item_name)}
+    items = m.get_menu.get_items.to_a
+  end
+  item = menu_items.detect {|i| i.text.split("\t").first == menu_item }
+  FakeEvent.new(Swt::SWT::Selection, item)
+end

data/plugins/application/features/step_definitions/navigation_history_steps.rb

@@ -0,0 +1,4 @@
+Then /^the focussed document path is "([^\"]*)"$/ do |path|
+  doc = Redcar.app.focussed_window.focussed_notebook_tab_document
+  doc.path.should == File.expand_path(path)
+end

data/plugins/application/features/step_definitions/speedbar_steps.rb

@@ -0,0 +1,88 @@
+
+Then /^the (.*) speedbar should be open$/ do |class_name|
+  Redcar.app.focussed_window.speedbar.class.to_s.should == class_name
+end
+
+def get_speedbar_text_field(field_name, speedbar=nil)
+  speedbar ||= Redcar.app.focussed_window.speedbar
+  item = speedbar.__get_item_by_label(field_name) ||
+          speedbar.__get_item_by_label(field_name + ":") ||
+          speedbar.__get_item(field_name)
+  expected_klass = Redcar::Speedbar::TextBoxItem
+  unless item.is_a?(expected_klass)
+    raise "expected #{item} to be a #{expected_klass}"
+  end
+  item
+end
+
+def get_speedbar_field(field_name, expected_klass, speedbar=nil)
+  speedbar ||= Redcar.app.focussed_window.speedbar
+  item = speedbar.__get_item_by_text_or_name(field_name)
+  unless item.is_a?(expected_klass)
+    raise "expected #{item} to be a #{expected_klass}"
+  end
+  item
+end
+
+When /^I type "([^"]*)" into the "([^"]*)" field in the speedbar$/ do |text, field_name|
+  get_speedbar_text_field(field_name).edit_view.document.text = text
+end
+
+When /^I press "([^"]*)" in the speedbar$/ do |button_name|
+  speedbar = Redcar.app.focussed_window.speedbar
+  speedbar.controller.execute_listener_in_model(speedbar.__get_item_by_text_or_name(button_name))
+end
+
+When /^I check "([^"]*)" in the speedbar$/ do |checkbox_name|
+  speedbar = Redcar.app.focussed_window.speedbar
+  item = speedbar.__get_item_by_text_or_name(checkbox_name)
+  item.set_value(true)
+  speedbar.controller.execute_listener_in_model(item, true)
+end
+
+When /^I uncheck "([^"]*)" in the speedbar$/ do |checkbox_name|
+  speedbar = Redcar.app.focussed_window.speedbar
+  item = speedbar.__get_item_by_text_or_name(checkbox_name)
+  item.set_value(false)
+  speedbar.controller.execute_listener_in_model(item, false)
+end
+
+When /^I choose "([^"]*)" in the "([^"]*)" field in the speedbar$/ do |value, combo_name|
+  speedbar = Redcar.app.focussed_window.speedbar
+  item = get_speedbar_field(combo_name, Redcar::Speedbar::ComboItem)
+  item.set_value(value)
+  speedbar.controller.execute_listener_in_model(item, value)
+end
+
+When /^I close the speedbar$/ do
+  Redcar.app.focussed_window.close_speedbar
+end
+
+Then /^the "([^"]*)" field in the speedbar should have text "([^"]*)"$/ do |field_name, text|
+  get_speedbar_text_field(field_name).edit_view.document.to_s.should == text
+end
+
+Then /^"([^"]*)" should( not)? be checked in the speedbar$/ do |checkbox_name, negate|
+  speedbar = Redcar.app.focussed_window.speedbar
+  item = speedbar.__get_item_by_text_or_name(checkbox_name)
+  if negate
+    item.value.should be_false
+  else
+    item.value.should be_true
+  end
+end
+
+Then /^"([^"]*)" should be chosen in the "([^"]*)" field in the speedbar$/ do |value, combo_name|
+  speedbar = Redcar.app.focussed_window.speedbar
+  item = get_speedbar_field(combo_name, Redcar::Speedbar::ComboItem, speedbar)
+  item.value.should == value
+end
+
+Then /^there should( not)? be an open speedbar$/ do |negate|
+  speedbar = Redcar.app.focussed_window.speedbar
+  if negate
+    speedbar.should == nil
+  else
+    speedbar.should_not == nil
+  end
+end

data/plugins/application/features/step_definitions/tree_steps.rb

@@ -0,0 +1,107 @@
+
+When /^I expand the tree row "([^\"]*)"$/ do |row|
+  item = visible_tree_items(top_tree).detect {|item| item.getText == row }
+  viewer = focussed_tree.controller.viewer
+  node = viewer.getViewerRowFromItem(item).getElement
+  viewer.expandToLevel(node, 1)
+end
+
+When /^I toggle tree visibility$/ do
+  Redcar::Application::ToggleTreesCommand.new.run
+end
+
+When "I close the tree" do
+  Redcar::Application::CloseTreeCommand.new.run
+end
+
+When /^I switch (up|down) a tree$/ do |type|
+  case type
+  when "down"
+    Redcar::Application::SwitchTreeDownCommand.new.run
+  when "up"
+    Redcar::Application::SwitchTreeUpCommand.new.run
+  end
+end
+
+When "I click the close button" do
+  vtabitem = focussed_window.treebook.controller.tab_folder.selection
+  swtlabel = swt_label_for_item(vtabitem)
+
+  # Make sure the close icon is showing
+  FakeEvent.new(Swt::SWT::MouseEnter, swtlabel)
+
+  # Fire the click event
+  FakeEvent.new(Swt::SWT::MouseUp, swtlabel,
+    :x => Swt::Widgets::VTabLabel::ICON_PADDING + 1,
+    :y => Swt::Widgets::VTabLabel::ICON_PADDING + 1)
+end
+
+When /^I (?:(left|right)-)?click the (project|directory|"[^\"]*") tree tab$/ do |button, target|
+  if target =~ /(project|directory)/
+    path  = Redcar::Project::Manager.in_window(Redcar.app.focussed_window).path
+    target = File.basename(path) + "/"
+  end
+  target.gsub!('"', '')
+  vtabitem = focussed_window.treebook.controller.tab_folder.get_item(target)
+  swtlabel = swt_label_for_item(vtabitem)
+
+  button = (button == "right" ? 2 : 1)
+  FakeEvent.new(Swt::SWT::MouseEnter, swtlabel)
+  FakeEvent.new(Swt::SWT::MouseUp, swtlabel, :x => 1, :y => 1, :button => button)
+end
+
+Then /^I should (not )?see "([^\"]*)" in the tree$/ do |negate, rows|
+  item_names = visible_tree_items(top_tree).map(&:get_text)
+  rows.split(',').map(&:strip).each do |row|
+    if negate
+      item_names.should_not include row
+    else
+      item_names.should include row
+    end
+  end
+end
+
+Then /^there should (not )?be a tree titled "([^\"]*)"$/ do |negate,title|
+  if negate
+    tree_with_title(title).should == nil
+  else
+    tree_with_title(title).should_not == nil
+  end
+end
+
+Then /^the focussed tree should be titled "([^\"]*)"$/ do |title|
+  focussed_tree.title.should == title
+end
+
+Then /^the tree width should be (the default|\d+ pixels|the minimum size)$/ do |w|
+  width = focussed_treebook_width
+  if w == "the default"
+    unless width == default_treebook_width
+      raise "The tree width was #{width}, expected #{default_treebook_width}"
+    end
+  elsif w == "the minimum size"
+    width.should == Redcar::ApplicationSWT::Window::MINIMUM_TREEBOOK_WIDTH
+  else
+    width.should == w.split(" ")[0].to_i
+  end
+end
+
+When /^I activate the "([^"]*)" node in the tree$/ do |node_text|
+  controller = focussed_tree.tree_controller
+  model      = focussed_tree.controller.model
+  mirror     = focussed_tree.tree_mirror
+  node       = find_node_with_text(mirror.top, node_text)
+
+  node.should_not be_nil
+
+  controller.activated(model, node)
+end
+
+When /^I rename the "([^"]*)" node in the tree$/ do |node_text|
+  controller = focussed_tree.tree_controller
+  mirror     = focussed_tree.tree_mirror
+  node       = find_node_with_text(mirror.top, node_text)
+
+  node.should_not be_nil
+  controller.single_rename(focussed_tree, node)
+end

data/plugins/application/features/step_definitions/window_steps.rb

@@ -0,0 +1,17 @@
+
+Then /^the window should have title "([^\"]*)"$/ do |expected_title|
+  active_shell.get_text.should == expected_title
+end
+
+When /^I set the treebook width to (the default|only a few pixels|the minimum width|\d+ pixels)$/ do |w|
+  if w == "only a few pixels"
+    width = 10
+  elsif w == "the minimum width"
+    width = Redcar::ApplicationSWT::Window::MINIMUM_TREEBOOK_WIDTH
+  elsif w == "the default"
+    width = default_treebook_width
+  else
+    width = w.split(" ")[0].to_i
+  end
+  focussed_window.controller.send(:set_sash_widths, width)
+end

data/plugins/application/features/support/env.rb

@@ -0,0 +1,257 @@
+require File.expand_path("../fake_event", __FILE__)
+
+class TestingError < StandardError
+end
+
+def get_menu_name text
+  Redcar::Menu.parse(text)
+end
+
+module SwtHelper
+  def main_menu
+    display = Redcar::ApplicationSWT.display
+    shell   = display.get_shells.to_a.first
+    menu_bar = shell.get_menu_bar
+    menu_bar
+  end
+
+  def first_shell
+    Redcar::ApplicationSWT.display.get_shells.to_a.first
+  end
+
+  def active_shell
+    focussed_window.controller.shell
+  end
+
+  def focussed_window
+    Redcar.app.focussed_window
+  end
+
+  def focussed_treebook_width
+    Redcar.app.focussed_window.controller.treebook_width
+  end
+
+  def focussed_tree
+    focussed_window.treebook.focussed_tree
+  end
+
+  def default_treebook_width
+    Redcar.app.focussed_window.controller.default_treebook_width
+  end
+
+  def tree_with_title(title)
+    focussed_window.treebook.trees.detect {|t| t.tree_mirror.title == title }
+  end
+
+  def dialog(type)
+    dialogs.detect {|d| d.is_a?(type) }
+  end
+
+  def dialogs
+    Redcar::ApplicationSWT.display.get_shells.to_a.map do |s|
+      Redcar::ApplicationSWT.shell_dialogs[s]
+    end.compact
+  end
+
+  def visible_tree_items(tree, items = [])
+    tree.getItems.to_a.each do |item|
+      items << item
+      visible_tree_items(item, items) if item.expanded?
+    end
+    return items
+  end
+
+  def top_tree
+    tree = focussed_tree.controller.viewer.get_tree
+    tree.extend(TreeHelpers)
+    tree
+  end
+
+  def find_node_with_text(top, node_text)
+    node = top.detect { |node| node.text == node_text }
+    return node if node
+    all_children = top.map{ |node| node.children }.flatten
+    find_node_with_text(all_children, node_text) unless all_children.empty?
+  end
+
+  def swt_label_for_item(vtabitem)
+    vtablabel = vtabitem.instance_variable_get "@label"
+    vtablabel.instance_variable_get "@label"
+  end
+
+  module TreeHelpers
+    def items
+      getItems.to_a
+    end
+
+    def item_texts
+      getItems.to_a.map {|item| item.getText}
+    end
+  end
+end
+
+class FakeDialogAdapter
+  def initialize
+    @responses = {}
+    @inputs = []
+  end
+
+  def set(method, value)
+    @responses[method] = value
+  end
+
+  def should_get_message(message)
+    @message = message
+  end
+
+  def should_get_popup_message(title,text)
+    @popup_message = text
+    @popup_title   = title
+  end
+
+  def should_get_popup_html(text)
+    @popup_html = text
+  end
+
+  def popup_html(*args)
+    unless @popup_text
+      raise TestingError.new("got a popup html dialog with text #{@popup_html.inspect} where I didn't expect one")
+    end
+    unless @popup_text == args.first.inspect
+      raise TestingError.new("expected text #{@popup_text.inspect}, got #{args.first.inspect}")
+    end
+  end
+
+  def popup_text(*args)
+    unless @popup_title and @popup_message
+      raise TestingError.new("got a popup dialog titled #{@popup_title.inspect} with text #{@popup_message.inspect} where I didn't expect one")
+    end
+    unless @popup_title == args.first
+      raise TestingError.new("expected title #{@popup_title.inspect}, got #{args.first.inspect}")
+    end
+    unless @popup_message == args[1]
+      raise TestingError.new("expected text #{@popup_message.inspect}, got #{args[1].inspect}")
+    end
+  end
+
+  def open_file(*args)
+    check_for_raise(@responses[:open_file])
+  end
+
+  def open_directory(*args)
+    check_for_raise(@responses[:open_directory])
+  end
+
+  def save_file(*args)
+    check_for_raise(@responses[:save_file])
+  end
+
+  def message_box(*args)
+    if @message == :any
+    elsif @message
+      unless @message == args.first
+        raise TestingError.new("expected the message #{@message.inspect} got #{args.first.inspect}")
+      end
+      @message = nil
+    else
+      raise TestingError.new("got a message box showing #{args.first.inspect} when I didn't expect one")
+    end
+    @responses[:message_box].to_sym if @responses[:message_box]
+  end
+
+  def input(*args)
+    if @inputs.length < 1
+      raise TestingError.new("No input added to complete this command.")
+    end
+    val = @inputs[0]
+    @inputs.delete_at(0)
+    {:value => val, :button => :ok}
+  end
+
+  def add_input(value)
+    @inputs << value
+  end
+
+  def clear_input
+    @inputs = []
+  end
+
+  def check_for_raise(result)
+    if result == :raise_error
+      raise TestingError.new("did not expect dialog")
+    end
+    result
+  end
+
+  def available_message_box_button_combos
+    Redcar::ApplicationSWT::DialogAdapter.new.available_message_box_button_combos
+  end
+
+  def available_message_box_types
+    Redcar::ApplicationSWT::DialogAdapter.new.available_message_box_types
+  end
+end
+
+World(SwtHelper)
+
+def close_everything
+  Redcar.app.task_queue.cancel_all
+  Swt.sync_exec do
+    dialogs.each {|d| d.controller.model.close }
+  end
+  Redcar.app.windows.each do |win|
+    if pr = Redcar::Project::Manager.in_window(win)
+      Swt.sync_exec do
+        pr.close
+      end
+    end
+    win.treebook.trees.each do |tree|
+      Swt.sync_exec do
+        win.treebook.remove_tree(tree)
+      end
+    end
+    win.notebooks.each do |notebook|
+      while tab = notebook.tabs.first
+        Swt.sync_exec do
+          tab.close
+        end
+      end
+    end
+    while win.notebooks.length > 1
+      Swt.sync_exec do
+        win.close_notebook
+      end
+    end
+  end
+  while Redcar.app.windows.length > 1
+    Swt.sync_exec do
+      Redcar.app.windows.last.close
+    end
+  end
+  Swt.sync_exec do
+    Redcar.app.focussed_window.close_speedbar if Redcar.app.focussed_window.speedbar
+    Redcar.app.windows.first.title = Redcar::Window::DEFAULT_TITLE
+  end
+end
+
+Before do
+  close_everything
+  Redcar::ApplicationSWT::FilterListDialogController.test_mode = true
+  Redcar.gui.register_dialog_adapter(FakeDialogAdapter.new)
+end
+
+After do
+  close_everything
+  errors = Redcar.app.history.select {|command| command.error }
+  Redcar.app.history.clear
+  if errors.any?
+    raise "Command errors #{errors.inspect}"
+  end
+  # total_mem = java.lang.Runtime.getRuntime.totalMemory
+  # free_mem  = java.lang.Runtime.getRuntime.freeMemory
+  # p [:total, total_mem/1000, :free, free_mem/1000, :diff, (total_mem - free_mem)/1000]
+end
+
+at_exit {
+  FileUtils.rm_rf(Redcar::Plugin::Storage.storage_dir)
+}