mohawk 0.1.4 → 0.2

data/spec/lib/mohawk/accessors/spinner_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-class SpinnerScreen
-  include Mohawk
-  window(:id => 123)
-
-  spinner(:price_is_right, :id => 'barker')
-end
-
-describe Mohawk::Accessors::Spinner do
-  let(:window) { double('RAutomation Window') }
-  let(:spinner) { double('RAutomation Spinner') }
-  subject { SpinnerScreen.new }
-
-  before(:each) do
-    RAutomation::Window.stub(:new).and_return(window)
-    window.should_receive(:spinner).with(:id => 'barker').and_return(spinner)
-  end
-
-  it 'knows the value' do
-    spinner.should_receive(:value).and_return(11.0)
-    subject.price_is_right.should eq(11.0)
-  end
-
-  it 'can set the value' do
-    spinner.should_receive(:set).with(11.0)
-    subject.price_is_right = 11.0
-  end
-
-  it 'can be incremented' do
-    spinner.should_receive(:increment).and_return(11.0)
-    subject.increment_price_is_right.should eq(11.0)
-  end
-
-  it 'can be decremented' do
-    spinner.should_receive(:decrement).and_return(11.0)
-    subject.decrement_price_is_right.should eq(11.0)
-  end
-
-  it 'can get the view' do
-    subject.price_is_right_view.should be(spinner)
-  end
-end

data/spec/lib/mohawk/accessors/table_row_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe Mohawk::Accessors::TableRow do
-  let(:table) { double('RAutomation Table') }
-  let(:adapter) { double('mohawk adapter') }
-  let(:mohawk_table) { Mohawk::Accessors::Table.new(adapter, value: 'whatever') }
-  let(:stubber) do
-    TableStubber.stub(table)
-    .with_headers('Name', 'Age')
-    .and_row('Levi', '33')
-  end
-
-  subject { Mohawk::Accessors::TableRow.new(mohawk_table, 0) }
-
-  before(:each) do
-    adapter.stub_chain(:window, :table).and_return(table)
-  end
-
-  it '#add_to_selection' do
-    stubber.rows[0].should_receive(:select)
-    subject.add_to_selection
-  end
-
-  it '#select' do
-    stubber.should_singly_select_row(0)
-    subject.select
-  end
-end

data/spec/lib/mohawk/accessors/table_spec.rb

@@ -1,262 +0,0 @@
-require 'spec_helper'
-
-class TableScreen
-  include Mohawk
-  window(:id => nil)
-
-  table(:top, :id => 'tableId')
-
-  # aliases
-  table(:my_default, :id => 'defaultAliasId')
-  listview(:my_listview, :id => 'listviewAliasId')
-  list_view(:my_list_view, :id => 'list_viewAliasId')
-end
-
-include RAutomation::Adapter::MsUia
-
-describe Mohawk::Accessors::Table do
-  let(:screen) { TableScreen.new }
-  let(:window) { double('RAutomation Window') }
-  let(:table) { double('Table') }
-
-  before(:each) do
-    RAutomation::Window.stub(:new).and_return(window)
-  end
-
-  context 'working with table controls' do
-    before(:each) do
-      window.should_receive(:table).with(:id => 'tableId').and_return(table)
-    end
-
-    it 'can select a row by index' do
-      stubber = TableStubber.stub(table)
-        .with_headers('Name')
-        .and_row('First Person')
-        .and_row('Second Person')
-
-      stubber.should_singly_select_row 1
-      screen.top = 1
-    end
-
-    it 'can select a row by value' do
-      stubber = TableStubber.stub(table)
-        .with_headers('Name')
-        .and_row('John Elway')
-
-      stubber.should_singly_select_row 0
-      screen.top = 'John Elway'
-    end
-
-    it 'can clear a row by index' do
-      stubber = TableStubber.stub(table)
-        .with_headers('Name').and_row('Whomever')
-
-      stubber.rows[0].should_receive(:clear)
-      screen.clear_top(0)
-    end
-
-    it 'can clear a row by value' do
-      stubber = TableStubber.stub(table)
-      .with_headers('Name').and_row('John Elway')
-
-      stubber.rows[0].should_receive(:clear)
-      screen.clear_top('John Elway')
-    end
-
-    context 'finding rows by Hash' do
-      it 'can find a row by hash' do
-        TableStubber.stub(table)
-        .with_headers('Favorite Color', 'Favorite Number', 'Name')
-        .and_row('Blue', '7', 'Levi')
-        .and_row('Purple', '9', 'Larry')
-
-        found_row = screen.find_top :favorite_number => 9
-        found_row.favorite_color.should eq('Purple')
-        found_row.favorite_number.should eq('9')
-        found_row.name.should eq('Larry')
-      end
-
-      it 'matches all values' do
-        stubber = TableStubber.stub(table)
-        .with_headers('Column One', 'Column Two', 'Column Three')
-        .and_row('first', 'something', 'foo')
-        .and_row('second', 'another', 'bar')
-
-        screen.find_top(:column_one => 'second', :column_three => 'bar').row.should eq(stubber.rows[1])
-      end
-
-      it 'can handle non-string values' do
-        stubber = TableStubber.stub(table)
-        .with_headers('name', 'age')
-        .and_row('Levi', '33')
-
-        screen.find_top(:age => 33).row.should eq(stubber.rows.first)
-      end
-
-      it 'raises if no row is found' do
-        TableStubber.stub(table)
-        .with_headers('Column One', 'Column Two', 'Column Three')
-        .and_row('first', 'something', 'foo')
-
-        expect { screen.find_top :column_one => 'not found' }.to raise_error "A row with {:column_one=>\"not found\"} was not found"
-      end
-    end
-
-    context 'selecting a row by hash' do
-      it 'singly selects the row' do
-        stubber = TableStubber.stub(table)
-        .with_headers('name', 'age')
-        .and_row('Levi', '33')
-        .and_row('John', '54')
-
-        stubber.should_singly_select_row(1)
-        screen.select_top(:age => 54)
-      end
-
-      it 'returns the row that it selected' do
-        stubber = TableStubber.stub(table)
-        .with_headers('name', 'age')
-        .and_row('Levi', '33')
-
-        stubber.should_singly_select_row(0)
-        screen.select_top(:age => 33).name.should eq('Levi')
-      end
-
-      it 'uses the find_row semantics' do
-        stubber = TableStubber.stub(table)
-          .with_headers('name', 'age')
-          .and_row('Levi', '33')
-
-        Mohawk::Accessors::Table.any_instance.should_receive(:find_row_with).with(:age => 33).and_call_original
-
-        stubber.should_singly_select_row(0)
-        screen.select_top :age => 33
-      end
-    end
-
-    context 'clearing a row by hash' do
-      it 'returns the row that it cleared' do
-        stubber = TableStubber.stub(table)
-        .with_headers('name', 'age')
-        .and_row('Levi', '33')
-
-        stubber.rows[0].should_receive(:clear)
-        screen.clear_top(:age => 33).name.should eq('Levi')
-      end
-
-      it 'uses the find_row semantics' do
-        stubber = TableStubber.stub(table)
-        .with_headers('name', 'age')
-        .and_row('Levi', '33')
-
-        Mohawk::Accessors::Table.any_instance.should_receive(:find_row_with).with(:age => 33).and_call_original
-
-        stubber.rows[0].should_receive(:clear)
-        screen.clear_top :age => 33
-      end
-    end
-
-    context 'adding a row to the selection' do
-      let(:stubber) do
-        TableStubber.stub(table)
-          .with_headers('name')
-          .and_row('Levi')
-          .and_row('John')
-      end
-
-      it 'returns the row that is added' do
-        stubber.rows[1].should_receive(:select)
-        screen.add_top(name: 'John').name.should eq('John')
-      end
-
-      it 'uses the find_row semantics' do
-        Mohawk::Accessors::Table.any_instance.should_receive(:find_row_with).with(name: 'Levi').and_call_original
-
-        stubber.rows[0].should_receive(:select)
-        screen.add_top name: 'Levi'
-      end
-    end
-
-    it 'has rows' do
-      TableStubber.stub(table)
-        .with_headers('Column')
-        .and_row('First Row')
-        .and_row('Second Row')
-
-      screen.top.map(&:column).should eq(['First Row', 'Second Row'])
-    end
-
-    it 'has headers' do
-      TableStubber.stub(table).with_headers('first header', 'second header')
-      screen.top_headers.should eq(['first header', 'second header'])
-    end
-
-    it 'can return the raw view' do
-      screen.top_view.should_not be_nil
-    end
-
-    describe Mohawk::Accessors::TableRow do
-      let(:table_stubber) { TableStubber.stub(table) }
-      before(:each) do
-        table_stubber.with_headers('column').and_row('first row')
-      end
-
-      it 'can get an individual row' do
-        screen.top[0].should_not be_nil
-      end
-
-      it 'knows if it is selected' do
-        table_stubber.rows[0].should_receive(:selected?).and_return(true)
-        screen.top[0].should be_selected
-      end
-
-      it 'can be selected' do
-        table_stubber.should_singly_select_row(0)
-        screen.top[0].select
-      end
-
-      it 'has cells' do
-        TableStubber.stub(table)
-          .with_headers('first', 'second')
-          .and_row('Cell 1', 'Cell 2')
-
-        screen.top[0].cells.should eq(['Cell 1', 'Cell 2'])
-      end
-
-      it 'can get cell values by header name' do
-        TableStubber.stub(table)
-          .with_headers('First Header', 'Second Header')
-          .and_row('Item 1', 'Item 2')
-
-        screen.top[0].second_header.should eq('Item 2')
-      end
-
-      it 'clearly lets you know if a header is not there' do
-        TableStubber.stub(table)
-          .with_headers('First Header', 'Second Header')
-          .and_row('Item 1', 'Item 2')
-
-        lambda { screen.top[0].does_not_exist }.should raise_error ArgumentError, 'does_not_exist column does not exist in [:first_header, :second_header]'
-      end
-    end
-  end
-
-  context 'aliases for table' do
-    let(:null_table) { double('Null ComboBox Field').as_null_object }
-    let(:table_aliases) { ['default', 'listview', 'list_view'] }
-
-    def expected_alias(id)
-      window.should_receive(:table).with(:id => "#{id}AliasId").ordered.and_return(null_table)
-    end
-
-    it 'has many aliases' do
-      table_aliases.each do |which_alias|
-        expected_alias which_alias
-      end
-
-      table_aliases.each do |which_alias|
-        screen.send "my_#{which_alias}_view"
-      end
-    end
-  end
-end

data/spec/lib/mohawk/accessors/tabs_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-class TabsScreen
-  include Mohawk
-  window(:id => 123)
-
-  tabs(:tab, :id => 'tabsId')
-end
-
-class TabItem
-  attr_reader :text, :index
-  def initialize(text, index)
-    @text, @index = text, index
-  end
-end
-
-describe Mohawk::Accessors::Tabs do
-  let(:window) { double('RAutomation Window') }
-  let(:tab_control) { double('RAutomation TabControl') }
-  subject { TabsScreen.new }
-
-  before(:each) do
-    RAutomation::Window.stub(:new).and_return(window)
-    window.should_receive(:tab_control).with(:id => 'tabsId').and_return(tab_control)
-  end
-
-  def tabs_are(*tabs)
-    expected = tabs.each_with_index.map {|t, i| TabItem.new(t, i) }
-    tab_control.should_receive(:items).and_return(expected)
-  end
-
-  it 'knows the currently selected tab' do
-    tab_control.should_receive(:value).and_return('Current Tab')
-
-    subject.tab.should eq('Current Tab')
-  end
-
-  it 'knows the available tabs' do
-    tabs_are('first', 'second')
-    subject.tab_items.should eq(['first', 'second'])
-  end
-
-  it 'can select tabs by index' do
-    tab_control.should_receive(:select).with(1)
-    subject.tab = 1
-  end
-
-  it 'can select tabs by value' do
-    tab_control.should_receive(:set).with('The Tab')
-    subject.tab = 'The Tab'
-  end
-
-  it 'can select tabs by regex' do
-    tabs_are('Something', 'With the Number 7')
-    tab_control.should_receive(:set).with('With the Number 7')
-    subject.tab = /\d+/
-  end
-end

data/spec/lib/mohawk/accessors/text_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-class TextScreen
-  include Mohawk
-  window(:id => nil)
-  
-  text(:text_id, :id => "textId")
-end
-
-describe Mohawk::Accessors::Text do
-  let(:screen) { TextScreen.new }
-  let(:window) { double("RAutomation Window") }
-  let(:text_field) { double("Text Field") }
-  let(:text_field_window) { double("Text Field Window") }
-
-  before(:each) do
-    RAutomation::Window.stub(:new).and_return(window)
-    window.should_receive(:text_field).with(:id => "textId").and_return(text_field)
-  end
-
-  context "accessing text controls" do
-
-    it "sets the text" do
-      text_field.should_receive(:set).with("the text value")
-      screen.text_id = "the text value"
-    end
-
-    it "retrieves the text" do
-      text_field.should_receive(:value).and_return("the text")
-      screen.text_id.should eq("the text")
-    end
-    
-    it "clears the text" do
-      text_field.should_receive(:clear)
-      screen.clear_text_id
-    end
-
-    it "enters the text" do
-      text_field.should_receive(:hwnd).and_return 123
-      window.should_receive(:child).with(:hwnd => 123).and_return(text_field_window)
-      text_field_window.should_receive(:send_keys).with("entered text".split(//))
-
-      screen.enter_text_id "entered text"
-    end
-
-    it "can dish out the text view" do
-      screen.text_id_view.should be(text_field)
-    end
-
-  end
-end

data/spec/lib/mohawk/accessors/tree_view_spec.rb

@@ -1,98 +0,0 @@
-require 'spec_helper'
-
-class TreeViewScreen
-  include Mohawk
-  window(:id => nil)
-
-  tree_view(:oak, :id => "treeViewId")
-
-  # aliases
-  tree_view(:my_default, :id => "defaultAliasId")
-  treeview(:my_treeview, :id => "treeviewAliasId")
-  tree(:my_tree, :id => "treeAliasId")
-end
-
-class FakeTreeItem
-  attr_reader :text
-
-  def initialize(item_text)
-    @text = item_text
-  end
-end
-
-describe Mohawk::Accessors::TreeView do
-  let(:screen) { TreeViewScreen.new }
-  let(:window) { double("RAutomation Window") }
-  let(:tree_field) { double("TreeView Field") }
-  let(:options) { double("TreeView Options") }
-  let(:option) { double("TreeView Option") }
-
-  before(:each) do
-    RAutomation::Window.stub(:new).and_return(window)
-    tree_field.stub(:options).and_return(options)
-  end
-
-  context "working with TreeView controls" do
-    before(:each) do
-      window.should_receive(:select_list).with(:id => "treeViewId").and_return(tree_field)
-    end
-
-    it "has a value" do
-      tree_field.should_receive(:value).and_return("tree value")
-      screen.oak.should eq "tree value"
-    end
-
-    it "can select items by index" do
-      options.should_receive(:[]).with(7).and_return(option)
-      option.should_receive(:select)
-
-      screen.oak = 7
-    end
-
-    it "can select items by their value" do
-      tree_field.should_receive(:option).with(text: 'item value').and_return(option)
-      option.should_receive(:select)
-
-      screen.oak = "item value"
-    end
-
-    it "can return the tree items" do
-      tree_field.should_receive(:options).and_return([FakeTreeItem.new("Item One"), FakeTreeItem.new("Item Two")])
-      screen.oak_items.should eq ["Item One", "Item Two"]
-    end
-
-    it "can expand items" do
-      tree_field.should_receive(:expand).with(7)
-      screen.expand_oak_item 7
-    end
-
-    it "can collapse items" do
-      tree_field.should_receive(:collapse).with("some item")
-      screen.collapse_oak_item "some item"
-    end
-
-    it "can work with the raw view" do
-      tree_field.should_receive(:visible?).and_return(true)
-      screen.oak_view.should be_visible
-    end
-  end
-
-  context "aliases for tree_view" do
-    let(:null_tree_view) { double("Null TreeView Field").as_null_object }
-    let(:tree_view_aliases) { ["default", "treeview", "tree"] }
-
-    def expected_alias(id)
-      window.should_receive(:select_list).with(:id => "#{id}AliasId").ordered.and_return(null_tree_view)
-    end
-
-    it "has many aliases" do
-      tree_view_aliases.each do |which_alias|
-        expected_alias which_alias
-      end
-
-      tree_view_aliases.each do |which_alias|
-        screen.send "my_#{which_alias}"
-      end
-    end
-  end
-end

data/spec/lib/mohawk/adapters/uia_adapter_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-class AnyScreen
-  include Mohawk
-  window(:title => /Some Title/, :children_only => true)
-end
-
-RSpec::Matchers.define(:use_the_cached) do |control_type, the_alias=nil|
-  match do |screen|
-    screen.adapter.window.stub(the_alias || control_type).and_return(double('first control'), double('second control'))
-    first, second = 2.times.map { screen.adapter.send(control_type, :id => 'id') }
-    first.eql?(second)
-  end
-end
-
-RSpec::Matchers.define(:only_search_children_for_a) do |control_type, the_alias=nil|
-  match do |screen|
-    screen.adapter.window.should_receive(the_alias || control_type).with(:id => 'id', :children_only => true).and_return(double('child control'))
-    screen.adapter.send(control_type, :id => 'id')
-    true
-  end
-end
-
-describe Mohawk::Adapters::UiaAdapter do
-  subject(:screen) { AnyScreen.new }
-
-  let(:window) { double('RAutomation Window') }
-  before(:each) { RAutomation::Window.stub(:new).and_return(window) }
-
-  context 'limiting searches to children only' do
-    it { should only_search_children_for_a(:combo, :select_list) }
-    it { should only_search_children_for_a(:checkbox) }
-    it { should only_search_children_for_a(:text, :text_field) }
-    it { should only_search_children_for_a(:button) }
-    it { should only_search_children_for_a(:radio) }
-    it { should only_search_children_for_a(:label) }
-    it { should only_search_children_for_a(:link, :label) }
-    it { should only_search_children_for_a(:table) }
-    it { should only_search_children_for_a(:tree_view, :select_list) }
-    it { should only_search_children_for_a(:value_control) }
-  end
-
-  context 'caching controls' do
-    it { should use_the_cached(:combo, :select_list) }
-    it { should use_the_cached(:checkbox) }
-    it { should use_the_cached(:text, :text_field) }
-    it { should use_the_cached(:button) }
-    it { should use_the_cached(:radio) }
-    it { should use_the_cached(:label) }
-    it { should use_the_cached(:link, :label) }
-    it { should use_the_cached(:table) }
-    it { should use_the_cached(:tree_view, :select_list) }
-    it { should use_the_cached(:value_control) }
-  end
-end

data/spec/table_stubber.rb

@@ -1,55 +0,0 @@
-require 'securerandom'
-
-class TableStubber
-  include RSpec::Mocks::ExampleMethods, RAutomation::Adapter::MsUia
-
-  attr_reader :table, :rows
-
-  def initialize(table)
-    @table = table
-    @id = SecureRandom.base64
-    @table.stub(:search_information).and_return(@id)
-    @table.stub(:selected_rows).and_return []
-    @rows = []
-  end
-
-  def self.stub(table)
-    TableStubber.new(table)
-  end
-
-  def with_headers(*headers)
-    UiaDll.stub(:table_headers).with(@id).and_return(headers.map(&:to_s))
-    self
-  end
-
-  def and_row(*values)
-    stub_cells_for(add_row, values)
-    self
-  end
-
-  def should_singly_select_row(which)
-    UiaDll.should_receive(:table_single_select).with(@id, which)
-  end
-
-  private
-  def add_row
-    row = double("table #{@id}, row #{rows.count}")
-    row.stub(:row).and_return(rows.count)
-    Row.stub(:new).with(table, :index => rows.count).and_return(row)
-    rows << row
-    table.stub(:row_count).and_return(rows.count)
-    row
-  end
-
-  def stub_cells_for(row, values)
-    cells = []
-    values.each_with_index do |value, index|
-      cell = double("Cell at #{row.row}, #{index}")
-      Cell.stub(:new).with(row, :index => index).and_return(cell)
-      cell.stub(:text).and_return(value)
-      cells << cell
-    end
-    row.stub(:value).and_return(values.first)
-    row.stub(:cells).and_return(cells)
-  end
-end