runo 0.1.0

data/t/test_password.rb

@@ -0,0 +1,188 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+require "#{::File.dirname __FILE__}/t"
+
+class TC_Password < Test::Unit::TestCase
+
+  def setup
+    @f = Runo::Field.instance(
+      :klass   => 'password',
+      :default => 'secret',
+      :size    => 16
+    )
+  end
+
+  def teardown
+  end
+
+  def test_get
+    @f.instance_variable_set(:@val, 'hello')
+
+    assert_equal(
+      '*****',
+      @f.get(:action => :read),
+      'Password#get should not return anything other than a dummy string'
+    )
+    assert_equal(
+      <<'_html'.chomp,
+<span class="password"><input type="password" name="" value="" size="16" /></span>
+_html
+      @f.get(:action => :create),
+      'Password#get(:action => :create) should return an empty form'
+    )
+
+    @f.update 'abcdefg'
+    assert_equal(
+      '*******',
+      @f.get(:action => :read),
+      'Password#get should refer to @size as a length of the dummy string'
+    )
+    assert_equal(
+      <<'_html'.chomp,
+<span class="password"><input type="password" name="" value="" size="16" /></span>
+_html
+      @f.get(:action => :update),
+      'Password#get(:action => :update) should return an empty form'
+    )
+  end
+
+  def test_load_default
+    @f.load_default
+    assert_nil(
+      @f.val,
+      'Password#load_default should not load any value'
+    )
+  end
+
+  def test_load
+    @f.load 'foobar'
+    assert_equal(
+      'foobar',
+      @f.val,
+      'Password#load should not alter the loaded value'
+    )
+  end
+
+  def test_create
+    @f.create 'foobar'
+    assert_not_equal(
+      'foobar',
+      @f.val,
+      'Password#create should store the value as a crypted string'
+    )
+  end
+
+  def test_create_empty
+    @f.create nil
+    assert_equal(
+      :create,
+      @f.action,
+      'Password#create should set @action even if the val is empty'
+    )
+  end
+
+  def test_update
+    @f.load 'original'
+
+    @f.update nil
+    assert_equal(
+      'original',
+      @f.val,
+      'Password#update should not update with nil'
+    )
+
+    @f.update ''
+    assert_equal(
+      'original',
+      @f.val,
+      'Password#update should not update with an empty string'
+    )
+
+    @f.update 'updated'
+    assert_not_equal(
+      'original',
+      @f.val,
+      'Password#update should update with a non-empty string'
+    )
+    assert_not_equal(
+      'updated',
+      @f.val,
+      'Password#update should store the value as a crypted string'
+    )
+  end
+
+  def test_errors_on_load
+    Runo.client = 'root'
+
+    @f[:min] = 1
+    @f.load ''
+    assert_equal(
+      [],
+      @f.errors,
+      'Password#errors should not return the errors of a loaded val'
+    )
+  end
+
+  def test_errors
+    @f.create nil
+    @f[:min] = 1
+    assert_equal(
+      ['mandatory'],
+      @f.errors,
+      'Password#errors should return the errors of the current val'
+    )
+
+    @f.create nil
+    assert_equal(
+      ['mandatory'],
+      @f.errors,
+      'Password#errors should keep the errors of the previous non-empty update'
+    )
+
+    @f.create 'a'
+    @f[:min] = 1
+    assert_equal(
+      [],
+      @f.errors,
+      'Password#errors should return the errors of the current val'
+    )
+    @f[:min] = 2
+    assert_equal(
+      ['too short: 2 characters minimum'],
+      @f.errors,
+      'Password#errors should return the errors of the current val'
+    )
+
+    @f.update 'abcde'
+    @f[:max] = 5
+    assert_equal(
+      [],
+      @f.errors,
+      'Password#errors should return the errors of the current val'
+    )
+    @f[:max] = 4
+    assert_equal(
+      ['too long: 4 characters maximum'],
+      @f.errors,
+      'Password#errors should return the errors of the current val'
+    )
+
+    @f.update nil
+    assert_equal(
+      ['too long: 4 characters maximum'],
+      @f.errors,
+      'Password#errors should keep the errors of the previous non-empty update'
+    )
+
+    @f.update 'abc'
+    assert_equal(
+      [],
+      @f.errors,
+      'Password#errors should return the errors of the current val'
+    )
+  end
+
+end

data/t/test_radio.rb

@@ -0,0 +1,226 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+require "#{::File.dirname __FILE__}/t"
+
+class TC_Radio < Test::Unit::TestCase
+
+  def setup
+    meta = nil
+    Runo::Parser.gsub_scalar("$(foo radio bar, baz, qux :'baz' mandatory)") {|id, m|
+      meta = m
+      ''
+    }
+    @f = Runo::Field.instance meta
+  end
+
+  def teardown
+  end
+
+  def test_meta
+    assert_equal(
+      ['bar', 'baz', 'qux'],
+      @f[:options],
+      'Radio#initialize should set :options from the csv token'
+    )
+    assert_equal(
+      true,
+      @f[:mandatory],
+      'Radio#initialize should set :mandatory from the misc token'
+    )
+    assert_equal(
+      'baz',
+      @f[:default],
+      'Radio#initialize should set :default from the token'
+    )
+  end
+
+  def test_meta_options_from_range
+    meta = nil
+    Runo::Parser.gsub_scalar("$(foo radio 1..5)") {|id, m|
+      meta = m
+      ''
+    }
+    f = Runo::Field.instance meta
+    assert_equal(
+      ['1', '2', '3', '4', '5'],
+      f[:options],
+      'Radio#initialize should set :options from the range token'
+    )
+
+    meta = nil
+    Runo::Parser.gsub_scalar("$(foo radio ..5)") {|id, m|
+      meta = m
+      ''
+    }
+    f = Runo::Field.instance meta
+    assert_equal(
+      ['0', '1', '2', '3', '4', '5'],
+      f[:options],
+      'Radio#initialize should set :options from the range token'
+    )
+
+    meta = nil
+    Runo::Parser.gsub_scalar("$(foo radio 1..)") {|id, m|
+      meta = m
+      ''
+    }
+    f = Runo::Field.instance meta
+    assert_equal(
+      nil,
+      f[:options],
+      'Radio#initialize should not refer to the range token if there is no maximum'
+    )
+  end
+
+  def test_val_cast
+    assert_equal(
+      '',
+      @f.val,
+      'Radio#val_cast should cast the given val to String'
+    )
+
+    @f.load 123
+    assert_equal(
+      '123',
+      @f.val,
+      'Radio#val_cast should cast the given val to String'
+    )
+  end
+
+  def test_get
+    @f.load ''
+    assert_equal(
+      '',
+      @f.get,
+      'Radio#get should return proper string'
+    )
+    assert_equal(
+      <<_html,
+<span class="radio">
+  <input type="hidden" name="" value="" />
+  <span class="item">
+    <input type="radio" id="radio_-bar" name="" value="bar" />
+    <label for="radio_-bar">bar</label>
+  </span>
+  <span class="item">
+    <input type="radio" id="radio_-baz" name="" value="baz" />
+    <label for="radio_-baz">baz</label>
+  </span>
+  <span class="item">
+    <input type="radio" id="radio_-qux" name="" value="qux" />
+    <label for="radio_-qux">qux</label>
+  </span>
+</span>
+_html
+      @f.get(:action => :create),
+      'Radio#get should return proper string'
+    )
+
+    @f.load 'qux'
+    assert_equal(
+      'qux',
+      @f.get,
+      'Radio#get should return proper string'
+    )
+    assert_equal(
+      <<_html,
+<span class="radio">
+  <input type="hidden" name="" value="" />
+  <span class="item">
+    <input type="radio" id="radio_-bar" name="" value="bar" />
+    <label for="radio_-bar">bar</label>
+  </span>
+  <span class="item">
+    <input type="radio" id="radio_-baz" name="" value="baz" />
+    <label for="radio_-baz">baz</label>
+  </span>
+  <span class="item">
+    <input type="radio" id="radio_-qux" name="" value="qux" checked />
+    <label for="radio_-qux">qux</label>
+  </span>
+</span>
+_html
+      @f.get(:action => :update),
+      'Radio#get should return proper string'
+    )
+
+    @f.load 'non-exist'
+    assert_equal(
+      <<_html,
+<span class="radio error">
+  <input type="hidden" name="" value="" />
+  <span class="item">
+    <input type="radio" id="radio_-bar" name="" value="bar" />
+    <label for="radio_-bar">bar</label>
+  </span>
+  <span class="item">
+    <input type="radio" id="radio_-baz" name="" value="baz" />
+    <label for="radio_-baz">baz</label>
+  </span>
+  <span class="item">
+    <input type="radio" id="radio_-qux" name="" value="qux" />
+    <label for="radio_-qux">qux</label>
+  </span>
+<span class=\"error_message\">no such option</span>
+</span>
+_html
+      @f.get(:action => :update),
+      'Radio#get should return proper string'
+    )
+  end
+
+  def test_get_escape
+    @f[:options] = ['foo', '<bar>']
+    @f.load '<bar>'
+    assert_equal(
+      '&lt;bar&gt;',
+      @f.get,
+      'Radio#get should escape the special characters'
+    )
+    assert_equal(
+      <<_html,
+<span class="radio">
+  <input type="hidden" name="" value="" />
+  <span class="item">
+    <input type="radio" id="radio_-foo" name="" value="foo" />
+    <label for="radio_-foo">foo</label>
+  </span>
+  <span class="item">
+    <input type="radio" id="radio_-&lt;bar&gt;" name="" value="&lt;bar&gt;" checked />
+    <label for="radio_-&lt;bar&gt;">&lt;bar&gt;</label>
+  </span>
+</span>
+_html
+      @f.get(:action => :update),
+      'Radio#get should escape the special characters'
+    )
+  end
+
+  def test_errors
+    @f.load ''
+    @f[:mandatory] = nil
+    assert_equal(
+      [],
+      @f.errors,
+      'Radio#errors should return the errors of the current val'
+    )
+    @f[:mandatory] = true
+    assert_equal(
+      ['mandatory'],
+      @f.errors,
+      'Radio#errors should return the errors of the current val'
+    )
+
+    @f.load 'non-exist'
+    @f[:mandatory] = nil
+    assert_equal(
+      ['no such option'],
+      @f.errors,
+      'Radio#errors should return the errors of the current val'
+    )
+  end
+
+end

data/t/test_role.rb

@@ -0,0 +1,249 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+require "#{::File.dirname __FILE__}/t"
+
+class TC_Role < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_owner
+    assert_equal(
+      'root',
+      Runo::Set::Static::Folder.root[:owner],
+      "Field#[:owner] should return 'root' for the root folder"
+    )
+
+    assert_equal(
+      'frank',
+      Runo::Set::Static::Folder.root.item('foo', 'main', '20091120_0001')[:owner],
+      'Field#[:owner] should return @meta[:owner] if available'
+    )
+    assert_equal(
+      'frank',
+      Runo::Set::Static::Folder.root.item('foo', 'main', '20091120_0001', 'replies')[:owner],
+      'Field#[:owner] should return parent[:owner] if @meta[:owner] is nil'
+    )
+    assert_equal(
+      'carl',
+      Runo::Set::Static::Folder.root.item('foo', 'main', '20091120_0001', 'replies', '20091201_0001')[:owner],
+      'Field#[:owner] should return @meta[:owner] if available'
+    )
+
+    assert_equal(
+      'root',
+      Runo::Set::Static::Folder.root.item('foo', 'bar')[:owner],
+      'Field#[:owner] should return parent[:owner] if @meta[:owner] is nil'
+    )
+    assert_equal(
+      'root',
+      Runo::Set::Static::Folder.root.item('foo', 'bar', 'main')[:owner],
+      'Field#[:owner] should return parent[:owner] if @meta[:owner] is nil'
+    )
+    assert_equal(
+      'carl',
+      Runo::Set::Static::Folder.root.item('foo', 'bar', 'main', '20091120_0001')[:owner],
+      'Field#[:owner] should return @meta[:owner] if available'
+    )
+    assert_equal(
+      'carl',
+      Runo::Set::Static::Folder.root.item('foo', 'bar', 'main', '20091120_0001', 'name')[:owner],
+      'Field#[:owner] should return parent[:owner] if @meta[:owner] is nil'
+    )
+  end
+
+  def test_owners
+    assert_equal(
+      ['root'],
+      Runo::Set::Static::Folder.root[:owners],
+      "Field#[:owners] should return ['root'] for the root folder"
+    )
+    assert_equal(
+      ['root'],
+      Runo::Set::Static::Folder.root.item('foo')[:owners],
+      'Field#[:owners] should return all the owners of the ancestor fields'
+    )
+    assert_equal(
+      ['root'],
+      Runo::Set::Static::Folder.root.item('foo', 'bar', 'main')[:owners],
+      'Field#[:owners] should return all the owners of the ancestor fields'
+    )
+    assert_equal(
+      ['root', 'carl'],
+      Runo::Set::Static::Folder.root.item('foo', 'bar', 'main', '20091120_0001')[:owners],
+      'Field#[:owners] should return all the owners of the ancestor fields'
+    )
+  end
+
+  def test_admins
+    assert_equal(
+      ['root'],
+      Runo::Set::Static::Folder.root[:admins],
+      "Field#[:admins] should return ['root'] for the root folder"
+    )
+    assert_equal(
+      ['root', 'frank'],
+      Runo::Set::Static::Folder.root.item('foo')[:admins],
+      'Field#[:admins] should include @meta[:admin] if available'
+    )
+    assert_equal(
+      ['root', 'frank'],
+      Runo::Set::Static::Folder.root.item('foo', 'main')[:admins],
+      'Field#[:admins] should return parent[:admins] if @meta[:admin] is nil'
+    )
+    assert_equal(
+      ['root', 'frank'],
+      Runo::Set::Static::Folder.root.item('foo', 'main', '20091120_0001')[:admins],
+      'Field#[:admins] should return parent[:admins] if @meta[:admin] is nil'
+    )
+
+    assert_equal(
+      ['root', 'frank'],
+      Runo::Set::Static::Folder.root.item('foo', 'bar')[:admins],
+      'Field#[:admins] should return parent[:admins] if @meta[:admin] is nil'
+    )
+    assert_equal(
+      ['root', 'frank'],
+      Runo::Set::Static::Folder.root.item('foo', 'bar', 'main')[:admins],
+      'Field#[:admins] should return parent[:admins] if @meta[:admin] is nil'
+    )
+    assert_equal(
+      ['root', 'frank'],
+      Runo::Set::Static::Folder.root.item('foo', 'bar', 'main', '20091120_0001')[:admins],
+      'Field#[:admins] should return @meta[:admins] if available'
+    )
+    assert_equal(
+      ['root', 'frank'],
+      Runo::Set::Static::Folder.root.item('foo', 'bar', 'main', '20091120_0001', 'name')[:admins],
+      'Field#[:admins] should return @meta[:admins] if available'
+    )
+  end
+
+  def test_group
+    assert_equal(
+      [],
+      Runo::Set::Static::Folder.root[:group],
+      "Field#[:group] should return [] for the root folder"
+    )
+    assert_equal(
+      ['roy', 'jim'],
+      Runo::Set::Static::Folder.root.item('foo')[:group],
+      'Field#[:group] should return @meta[:group] if available'
+    )
+    assert_equal(
+      ['roy', 'jim'],
+      Runo::Set::Static::Folder.root.item('foo', 'main')[:group],
+      'Field#[:group] should return @meta[:group] of the nearest folder'
+    )
+    assert_equal(
+      ['roy', 'jim'],
+      Runo::Set::Static::Folder.root.item('foo', 'main', '20091120_0001')[:group],
+      'Field#[:group] should return @meta[:group] of the nearest folder'
+    )
+
+    assert_equal(
+      ['carl', 'don'],
+      Runo::Set::Static::Folder.root.item('foo', 'bar')[:group],
+      'Field#[:group] should return @meta[:group] if available'
+    )
+    assert_equal(
+      ['carl', 'don'],
+      Runo::Set::Static::Folder.root.item('foo', 'bar', 'main')[:group],
+      'Field#[:group] should return @meta[:group] of the nearest folder'
+    )
+  end
+
+  def test_roles_of_nobody
+    Runo.client = nil
+    assert_equal(
+      0b00001,
+      Runo::Set::Static::Folder.root[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+    assert_equal(
+      0b00001,
+      Runo::Set::Static::Folder.root.item('foo')[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+    assert_equal(
+      0b00001,
+      Runo::Set::Static::Folder.root.item('foo', 'main')[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+    assert_equal(
+      0b00001,
+      Runo::Set::Static::Folder.root.item('foo', 'main', '20091120_0001')[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+    assert_equal(
+      0b00001,
+      Runo::Set::Static::Folder.root.item('foo', 'bar')[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+  end
+
+  def test_roles_of_frank
+    Runo.client = 'frank'
+    assert_equal(
+      0b00010,
+      Runo::Set::Static::Folder.root[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+    assert_equal(
+      0b10010,
+      Runo::Set::Static::Folder.root.item('foo')[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+    assert_equal(
+      0b10010,
+      Runo::Set::Static::Folder.root.item('foo', 'main')[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+    assert_equal(
+      0b10110,
+      Runo::Set::Static::Folder.root.item('foo', 'main', '20091120_0001')[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+    assert_equal(
+      0b10010,
+      Runo::Set::Static::Folder.root.item('foo', 'bar')[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+  end
+
+  def test_roles_of_roy
+    Runo.client = 'roy'
+    assert_equal(
+      0b00010,
+      Runo::Set::Static::Folder.root[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+    assert_equal(
+      0b01010,
+      Runo::Set::Static::Folder.root.item('foo')[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+    assert_equal(
+      0b01010,
+      Runo::Set::Static::Folder.root.item('foo', 'main')[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+    assert_equal(
+      0b01010,
+      Runo::Set::Static::Folder.root.item('foo', 'main', '20091120_0001')[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+    assert_equal(
+      0b00010,
+      Runo::Set::Static::Folder.root.item('foo', 'bar')[:roles],
+      'Field#[:roles] should return the roles of the client on the field'
+    )
+  end
+
+end