Class: Mongoid::Matchers::Associations::HaveAssociationMatcher

Inherits:
Object
  • Object
show all
Defined in:
lib/matchers/associations.rb

Instance Method Summary collapse

Constructor Details

#initialize(name, association_type) ⇒ HaveAssociationMatcher

Returns a new instance of HaveAssociationMatcher.



17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/matchers/associations.rb', line 17

def initialize(name, association_type)
  @association = {}
  @association[:name] = name.to_s
  @association[:type] = association_type
  # begin
  #   @association[:class] = name.to_s.classify.constantize
  # rescue
  # end
  @expectation_message = "#{type_description} #{@association[:name].inspect}"
  @expectation_message << " of type #{@association[:class].inspect}" unless @association[:class].nil?
end

Instance Method Details

#as_inverse_of(association_inverse_name) ⇒ Object 



35
36
37
38
39
40
 
# File 'lib/matchers/associations.rb', line 35

def as_inverse_of(association_inverse_name)
  raise "#{@association[:type].inspect} does not respond to :inverse_of" unless [BELONGS_TO, EMBEDDED_IN].include?(@association[:type])
  @association[:inverse_of] = association_inverse_name.to_s
  @expectation_message << " which is an inverse of #{@association[:inverse_of].inspect}"
  self
end

#description ⇒ Object 



88
89
90
 
# File 'lib/matchers/associations.rb', line 88

def description
  @expectation_message
end

#failure_message_for_should ⇒ Object 



80
81
82
 
# File 'lib/matchers/associations.rb', line 80

def failure_message_for_should
  "Expected #{@actual.inspect} to #{@expectation_message}, got #{@negative_result_message}"
end

#failure_message_for_should_not ⇒ Object 



84
85
86
 
# File 'lib/matchers/associations.rb', line 84

def failure_message_for_should_not
  "Expected #{@actual.inspect} to not #{@expectation_message}, got #{@positive_result_message}"
end

#matches?(actual) ⇒ Boolean

Returns:

  • (Boolean) 


42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/matchers/associations.rb', line 42

def matches?(actual)
  @actual = actual.is_a?(Class) ? actual : actual.class
  metadata = @actual.relations[@association[:name]]

  if metadata.nil?
    @negative_result_message = "no association named #{@association[:name]}"
    return false
  else
    @positive_result_message = "association named #{@association[:name]}"
  end

  relation = metadata.relation
  if relation != @association[:type]
    @negative_result_message = "#{@actual.inspect} #{type_description(relation, false)} #{@association[:name]}"
    return false
  else
    @positive_result_message = "#{@actual.inspect} #{type_description(relation, false)} #{@association[:name]}"
  end

  if !@association[:class].nil? and @association[:class] != metadata.klass
    @negative_result_message = "#{@positive_result_message} of type #{metadata.klass.inspect}"
    return false
  else
    @positive_result_message = "#{@positive_result_message} of type #{metadata.klass.inspect}"
  end

  if @association[:inverse_of]
    if @association[:inverse_of].to_s != metadata.inverse_of.to_s
      @negative_result_message = "#{@positive_result_message} which is an inverse of #{metadata.inverse_of}"
      return false
    else
      @positive_result_message = "#{@positive_result_message} which is an inverse of #{metadata.inverse_of}"
    end
  end

  true
end

#of_type(klass) ⇒ Object 



29
30
31
32
33
 
# File 'lib/matchers/associations.rb', line 29

def of_type(klass)
  @association[:class] = klass
  @expectation_message << " of type #{@association[:class].inspect}"
  self
end

#type_description(type = nil, passive = true) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/matchers/associations.rb', line 92

def type_description(type = nil, passive = true)
  type ||= @association[:type]
  case type.name
  when EMBEDS_ONE.name
    (passive ? 'embed' : 'embeds') << ' one'
  when EMBEDS_MANY.name
    (passive ? 'embed' : 'embeds') << ' many'
  when EMBEDDED_IN.name
    (passive ? 'be' : 'is') << ' embedded in'
  when HAS_ONE.name
    (passive ? 'reference' : 'references') << ' one'
  when HAS_MANY.name
    (passive ? 'reference' : 'references') << ' many'
  when HAS_AND_BELONGS_TO_MANY.name
    (passive ? 'reference' : 'references') << ' and referenced in many'
  when BELONGS_TO.name
    (passive ? 'be referenced in' : 'referenced in')
  else
    raise "Unknown association type '%s'" % type
  end
end