Module: Ccp::Receivers::Fixtures

Defined in:
lib/ccp/receivers/fixtures.rb

Instance Method Summary collapse

Instance Method Details

#default_fixture_fail(cmd, key, exp, got) ⇒ Object 



86
87
88
 
# File 'lib/ccp/receivers/fixtures.rb', line 86

def default_fixture_fail(cmd, key, exp, got)
  Ccp::Utils::TestFailed::PROC.call(cmd, key, exp, got)
end

#default_fixture_path_for ⇒ Object 



155
156
157
 
# File 'lib/ccp/receivers/fixtures.rb', line 155

def default_fixture_path_for
  proc{|cmd| settings.path(:fixture_dir) + cmd.class.name.underscore}
end

#execute(cmd) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/ccp/receivers/fixtures.rb', line 4

def execute(cmd)
  if fixture_save?(cmd)
    observer = Ccp::Fixtures::Observer.new(data)
    observer.start
    super
    observer.stop
    fixture_save(cmd, observer.read, observer.write)

  elsif fixture_test?(cmd)
    stub = fixture_versioned_for(cmd)["stub"].path
    fixture_stub(cmd.class.stub || (stub.exist? ? stub : nil))
    super
    mock = fixture_versioned_for(cmd)["mock"].path
    fixture_mock(cmd, cmd.class.mock || mock)

  else
    fixture_stub(cmd.class.stub)
    super
    fixture_mock(cmd, cmd.class.mock)
  end
end

#fixture_fail(cmd, key, expected = nil, got = nil) ⇒ Object 



77
78
79
80
 
# File 'lib/ccp/receivers/fixtures.rb', line 77

def fixture_fail(cmd, key, expected = nil, got = nil)
  block = fixture_fail_for(cmd)
  instance_exec(cmd, key, expected, got, &block)
end

#fixture_fail_for(cmd) ⇒ Object 



82
83
84
 
# File 'lib/ccp/receivers/fixtures.rb', line 82

def fixture_fail_for(cmd)
  cmd.class.fail || method(:default_fixture_fail)
end

#fixture_keys_filter(acl, keys) ⇒ Object 



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/ccp/receivers/fixtures.rb', line 138

def fixture_keys_filter(acl, keys)
  case acl
  when true ; keys
  when false; []
  when Array
    ary = acl.map(&:to_s)
    return keys if ary == []
    if ary.size == ary.grep(/^!/).size
      return keys.dup.reject{|v| ary.include?("!#{v}")}
    else
      ary & keys
    end
  else
    raise ":fixture_keys is invalid: #{acl.class}"
  end
end

#fixture_mock(cmd, path) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
 
# File 'lib/ccp/receivers/fixtures.rb', line 60

def fixture_mock(cmd, path)
  return unless path
  hash = Ccp::Persistent.load(path).read!

  hash.keys.each do |key|
    fixture_validate(cmd, key, data, hash)
  end
rescue Ccp::Persistent::NotFound => e
  raise Ccp::Fixtures::NotFound, e.to_s
end

#fixture_save(cmd, stub, mock) ⇒ Object 



108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/ccp/receivers/fixtures.rb', line 108

def fixture_save(cmd, stub, mock)
  versioned = fixture_versioned_for(cmd)
  keys = cmd.class.keys || self[:fixture_keys]
  kvs  = Ccp::Persistent.lookup(versioned.kvs)

  # stub
  storage = cmd.class.stub ? kvs.new(cmd.class.stub, versioned.ext) : versioned["stub"]
  storage.save(stub, fixture_keys_filter(keys, stub.keys))

  # mock
  storage = cmd.class.mock ? kvs.new(cmd.class.mock, versioned.ext) : versioned["mock"]
  storage.save(mock, fixture_keys_filter(keys, mock.keys))
end

#fixture_save?(cmd) ⇒ Boolean

Returns:

  • (Boolean) 


90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/ccp/receivers/fixtures.rb', line 90

def fixture_save?(cmd)
  return true if cmd.class.save # highest priority

  case (obj = self[:fixture_save])
  when true  ; true
  when false ; false
  when String; cmd.class.name == obj
  when Array ; ary = obj.map(&:to_s); name = cmd.class.name
    return false if ary.blank?
    return true  if ary.include?(name)
    return false if ary.include?("!#{name}")
    return true  if ary.size == ary.grep(/^!/).size
    return false
  when Proc  ; instance_exec(cmd, &obj).must(true,false) {raise ":fixture_save should return true|false"}
  else; raise ":fixture_save is invalid: #{obj.class}"
  end
end

#fixture_stub(path) ⇒ Object 



52
53
54
55
56
57
58
 
# File 'lib/ccp/receivers/fixtures.rb', line 52

def fixture_stub(path)
  return unless path
  hash = Ccp::Persistent.load(path).read!
  data.merge!(hash)
rescue Ccp::Persistent::NotFound => e
  raise Ccp::Fixtures::NotFound, e.to_s
end

#fixture_test?(cmd) ⇒ Boolean

Returns:

  • (Boolean) 


122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/ccp/receivers/fixtures.rb', line 122

def fixture_test?(cmd)
  case (obj = self[:fixture_test])
  when true  ; true
  when false ; false
  when String; cmd.class.name == obj
  when Array ; ary = obj.map(&:to_s); name = cmd.class.name
    return false if ary.blank?
    return true  if ary.include?(name)
    return false if ary.include?("!#{name}")
    return true  if ary.size == ary.grep(/^!/).size
    return false
  when Proc  ; instance_exec(cmd, &obj).must(true,false) {raise ":fixture_test should return true|false"}
  else; raise ":fixture_test is invalid: #{obj.class}"
  end
end

#fixture_validate(cmd, key, data, hash) ⇒ Object 



71
72
73
74
75
 
# File 'lib/ccp/receivers/fixtures.rb', line 71

def fixture_validate(cmd, key, data, hash)
  data.exist?(key)       or fixture_fail(cmd, key)
  data[key] == hash[key] or fixture_fail(cmd, key, hash[key], data[key])
  # or, success
end

#parse!(options) ⇒ Object 



44
45
46
47
48
49
50
 
# File 'lib/ccp/receivers/fixtures.rb', line 44

def parse!(options)
  settings.keys.grep(/^fixture_/).each do |key|
    self[key] = options.delete(key.to_sym) if options.has_key?(key.to_sym)
    self[key] = options.delete(key) if options.has_key?(key)
  end
  super
end

#setup ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/ccp/receivers/fixtures.rb', line 26

def setup
  super

  # Schema
  self[:fixture_save]     = Object # Define schema explicitly to accept true|false|Proc
  self[:fixture_test]     = Object # Define schema explicitly to accept true|false|Proc
  self[:fixture_keys]     = Object # Define schema explicitly to accept true|[String]

  # Values
  self[:fixture_dir]      = "tmp/fixtures"
  self[:fixture_kvs]      = :file
  self[:fixture_ext]      = :json
  self[:fixture_save]     = false
  self[:fixture_test]     = false
  self[:fixture_keys]     = true
  self[:fixture_path_for] = default_fixture_path_for
end