Module: Micro::Case::Check::Enabled

Extended by:
Enabled
Included in:
Enabled
Defined in:
lib/micro/case/check.rb

Instance Method Summary collapse

Instance Method Details

#activerecord_loaded! ⇒ Object

Raises:



95
96
97
98
99
 
# File 'lib/micro/case/check.rb', line 95

def activerecord_loaded!
  return if defined?(::ActiveRecord::Base)

  raise ::Micro::Cases::Error::TransactionAdapterMissing
end

#expected_result!(result, context) ⇒ Object

Raises:



33
34
35
36
37
 
# File 'lib/micro/case/check.rb', line 33

def expected_result!(result, context)
  return if result.is_a?(::Micro::Case::Result)

  raise Error::UnexpectedResult.new(context)
end

#expected_self_result!(actual, expected, context) ⇒ Object

Raises:



39
40
41
42
43
 
# File 'lib/micro/case/check.rb', line 39

def expected_self_result!(actual, expected, context)
  return if actual.equal?(expected)

  raise Error::UnexpectedResult.new(context)
end

#flow_steps_kwarg!(args, steps, label) ⇒ Object

Raises:

  • (ArgumentError) 


63
64
65
66
67
68
 
# File 'lib/micro/case/check.rb', line 63

def flow_steps_kwarg!(args, steps, label)
  return unless args && steps

  raise ArgumentError,
    "#{label} accepts a positional collection OR `steps:`, not both"
end

#flow_use_cases!(use_cases) ⇒ Object

Raises:



51
52
53
 
# File 'lib/micro/case/check.rb', line 51

def flow_use_cases!(use_cases)
  raise Cases::Error::InvalidUseCases if use_cases.none?(&::Micro::Cases::Flow::IsAValidUseCase)
end

#hash!(arg) ⇒ Object 



59
60
61
 
# File 'lib/micro/case/check.rb', line 59

def hash!(arg)
  Kind::Hash[arg]
end

#map_args!(args) ⇒ Object

Raises:



55
56
57
 
# File 'lib/micro/case/check.rb', line 55

def map_args!(args)
  raise Cases::Error::InvalidUseCases unless ::Micro::Cases::Map.const_get(:HasValidArgs, false)[args]
end

#micro_case_instance!(arg) ⇒ Object

Raises:



13
14
15
 
# File 'lib/micro/case/check.rb', line 13

def micro_case_instance!(arg)
  raise Error::InvalidUseCase unless arg.is_a?(::Micro::Case)
end

#result_data!(data, is_success, type, use_case) ⇒ Object

Raises:



29
30
31
 
# File 'lib/micro/case/check.rb', line 29

def result_data!(data, is_success, type, use_case)
  raise Error::InvalidResult.new(is_success, type, use_case) unless data
end

#result_instance!(arg) ⇒ Object

Raises:



17
18
19
 
# File 'lib/micro/case/check.rb', line 17

def result_instance!(arg)
  raise Error::InvalidResultInstance unless arg.is_a?(::Micro::Case::Result)
end

#result_not_defined!(is_defined) ⇒ Object

Raises:



21
22
23
 
# File 'lib/micro/case/check.rb', line 21

def result_not_defined!(is_defined)
  raise Error::ResultIsAlreadyDefined if is_defined
end

#result_type!(type) ⇒ Object

Raises:



25
26
27
 
# File 'lib/micro/case/check.rb', line 25

def result_type!(type)
  raise Error::InvalidResultType unless type.is_a?(Symbol)
end

#results_contract!(use_case_class, kind, type, value) ⇒ Object

Raises:



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/micro/case/check.rb', line 124

def results_contract!(use_case_class, kind, type, value)
  contract = use_case_class.__results_contract__
  return unless contract
  return unless type.is_a?(Symbol)
  return if value.is_a?(Exception)

  if kind == :success
    declared = contract.success_declared?(type)
    declared_types = contract.successes.keys
    required = contract.success_keys(type) if declared
  else
    declared = contract.failure_declared?(type)
    declared_types = contract.failures.keys
    required = contract.failure_keys(type) if declared
  end

  raise Error::UnexpectedResultType.new(use_case_class, kind, type, declared_types) unless declared
  return if required.nil? || required.empty?

  if value.is_a?(Hash)
    data_keys = value.keys.map { |k| k.is_a?(String) ? k.to_sym : k }
  elsif value.is_a?(Symbol)
    data_keys = [type]
  else
    return
  end

  missing = required - data_keys

  raise Error::MissingResultKeys.new(use_case_class, kind, type, missing) unless missing.empty?
end

#then_use_case_or_flow!(arg, owner_label) ⇒ Object

Raises:



45
46
47
48
49
 
# File 'lib/micro/case/check.rb', line 45

def then_use_case_or_flow!(arg, owner_label)
  return if ::Micro.case_or_flow?(arg)

  raise Error::InvalidInvocationOfTheThenMethod.new(owner_label)
end

#transaction_class_callback!(callable) ⇒ Object

Raises:

  • (ArgumentError) 


117
118
119
120
121
122
 
# File 'lib/micro/case/check.rb', line 117

def transaction_class_callback!(callable)
  return if callable.respond_to?(:call)

  raise ArgumentError,
    "Micro::Case.config.default_transaction_class= expects a callable (a block, lambda or proc), got #{callable.inspect}"
end

#transaction_kwarg!(value) ⇒ Object

Raises:

  • (ArgumentError) 


70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/micro/case/check.rb', line 70

def transaction_kwarg!(value)
  return nil if value.nil? || value == false
  return true if value == true

  if value.is_a?(Class)
    transaction_owner!(value)
    return value
  end

  if value.is_a?(Hash)
    extra = value.keys - [:with]

    raise ArgumentError,
      "transaction: unsupported key(s) #{extra.inspect} (only `:with` is accepted)" unless extra.empty?

    with = value[:with]
    transaction_owner!(with)

    return with
  end

  raise ArgumentError,
    "transaction: #{value.inspect} is not supported (accepts `true`, `false`, `nil`, or `{ with: SomeARClass }`)"
end

#transaction_owner!(klass) ⇒ Object

Validates a transaction owner class. We accept Class instances only; the AR-subclass check is enforced if (and only if) ActiveRecord is already loaded — otherwise we defer to runtime so that load-order quirks (Rails initializers running before the AR autoload) don’t break class-eval-time declarations.

Raises:

  • (ArgumentError) 


106
107
108
109
110
111
112
113
114
115
 
# File 'lib/micro/case/check.rb', line 106

def transaction_owner!(klass)
  raise ArgumentError,
    "transaction owner #{klass.inspect} must be a subclass of ActiveRecord::Base" unless klass.is_a?(Class)

  return unless defined?(::ActiveRecord::Base)
  return if klass <= ::ActiveRecord::Base

  raise ArgumentError,
    "transaction owner #{klass.inspect} must be a subclass of ActiveRecord::Base"
end

#use_case_or_flow!(arg) ⇒ Object

Raises:



9
10
11
 
# File 'lib/micro/case/check.rb', line 9

def use_case_or_flow!(arg)
  raise Error::InvalidUseCase unless ::Micro.case_or_flow?(arg)
end