Module: Test::Unit::Data::ClassMethods

Defined in:: lib/test/unit/data.rb,
lib/test/unit/data.rb

Defined Under Namespace

Classes: Loader

Instance Method Summary collapse

#data(*arguments, &block) ⇒ Object
This method provides Data-Driven-Test functionality.
#load_data(file_name) ⇒ Object
This method provides Data-Driven-Test functionality.

Instance Method Details

#data(label, data, options = {}) ⇒ `Object` #data(variable, patterns, options = {}) ⇒ `Object` #data(data_set, options = {}) ⇒ `Object` #data(options = {}, &block) ⇒ `Object` #data(options = {}, &block) ⇒ `Object`

This method provides Data-Driven-Test functionality.

Define test data in the test code.

Overloads:

#data(label, data, options = {}) ⇒ Object
Examples:

data(label, data)
```
data("empty string", [true, ""])
data("plain string", [false, "hello"])
def test_empty?(data)
  expected, target = data
  assert_equal(expected, target.empty?)
end
```
Parameters:
- label (String) —
  specify test case name.
- data —
  specify test data.
- options (Hash) (defaults to: {}) —
  specify options.
Options Hash (options):
- :keep (Boolean) —
  whether or not to use this data in the following test methods
#data(variable, patterns, options = {}) ⇒ Object

Generates test matrix from variable and patterns pairs.
Examples:

data(variable, patterns)
```
data(:x, [1, 2, 3])
data(:y, ["a", "b"])
def test_patterns(data)
  # 3 * 2 times executed
  # 3: the number of patterns of :x
  # 2: the number of patterns of :y
  p data
    # => {:x => 1, :y => "a"}
    # => {:x => 1, :y => "b"}
    # => {:x => 2, :y => "a"}
    # => {:x => 2, :y => "b"}
    # => {:x => 3, :y => "a"}
    # => {:x => 3, :y => "b"}
end
```
Parameters:
- variable (Symbol) —
  specify test pattern variable name.
- patterns (Array) —
  specify test patterns for the variable.
- options (Hash) (defaults to: {}) —
  specify options.
Options Hash (options):
- :keep (Boolean) —
  whether or not to use this data in the following test methods
- :group (Object) —
  the test pattern group. Test matrix is generated for each test pattern group separately.
#data(data_set, options = {}) ⇒ Object
Examples:

data(data_set)
```
data("empty string" => [true, ""],
     "plain string" => [false, "hello"])
def test_empty?(data)
  expected, target = data
  assert_equal(expected, target.empty?)
end
```
Parameters:
- data_set (Hash) —
  specify test data as a Hash that key is test label and value is test data.
- options (Hash) (defaults to: {}) —
  specify options.
Options Hash (options):
- :keep (Boolean) —
  whether or not to use this data in the following test methods
#data(options = {}, &block) ⇒ Object
Examples:

data(&block)
```
data do
  data_set = {}
  data_set["empty string"] = [true, ""]
  data_set["plain string"] = [false, "hello"]
  data_set
end
def test_empty?(data)
  expected, target = data
  assert_equal(expected, target.empty?)
end
```
Parameters:
- options (Hash) (defaults to: {}) —
  specify options.
Options Hash (options):
- :keep (Boolean) —
  whether or not to use this data in the following test methods
Yield Returns:
- (Hash<String, Object>) —
  return test data set as a Hash that key is test label and value is test data.

#data(options = {}, &block) ⇒ Object

Generates test matrix from variable and patterns pairs.

Examples:

data(&block)

data do
  patterns = 3.times.to_a
  [:x, patterns]
end
data do
  patterns = []
  character = "a"
  2.times.each do
    patterns << character
    character = character.succ
  end
  [:y, patterns]
end
def test_patterns(data)
  # 3 * 2 times executed
  # 3: the number of patterns of :x
  # 2: the number of patterns of :y
  p data
    # => {:x => 0, :y => "a"}
    # => {:x => 0, :y => "b"}
    # => {:x => 1, :y => "a"}
    # => {:x => 1, :y => "b"}
    # => {:x => 2, :y => "a"}
    # => {:x => 2, :y => "b"}
end

Parameters:

options (Hash) (defaults to: {}) —
specify options.

Options Hash (options):

:keep (Boolean) —
whether or not to use this data in the following test methods

Yield Returns:

(Array<Symbol, Array>) —
return test data set as an Array of variable and patterns.

# File 'lib/test/unit/data.rb', line 55

def data(*arguments, &block)
  n_arguments = arguments.size
  case n_arguments
  when 0
    raise ArgumentError, "no block is given" unless block_given?
    data_set = block
  when 1
    data_set = arguments[0]
  when 2
    data_set = {arguments[0] => arguments[1]}
  else
    message = "wrong number arguments(#{n_arguments} for 1..2)"
    raise ArgumentError, message
  end
  current_data = current_attribute(:data)[:value] || []
  attribute(:data, current_data + [data_set])
end

#load_data(file_name) ⇒ `Object`

This method provides Data-Driven-Test functionality.

Load test data from the file. This is shorthand to load test data from file. If you want to load complex file, you can use #data with block.

Examples:

Load data from CSV file

load_data("/path/to/test-data.csv")
def test_empty?(data)
  assert_equal(data["expected"], data["target"].empty?)
end