zf

zenflows testing
git clone https://s.sonu.ch/~srfsh/zf.git
Log | Files | Refs | Submodules | README | LICENSE

track_and_trace.test.exs (7797B)


      1 defmodule ZenflowsTest.VF.EconomicEvent.TrackAndTrace do
      2 use ZenflowsTest.Help.EctoCase, async: true
      3 
      4 alias Zenflows.VF.{
      5 	EconomicEvent.Domain,
      6 	EconomicResource,
      7 	Process,
      8 }
      9 
     10 test "previous/2 works" do
     11 	agent = Factory.insert!(:agent)
     12 	unit = Factory.insert!(:unit)
     13 	amount = Factory.decimal()
     14 
     15 	evt0 = Domain.create!(%{
     16 			action_id: "raise",
     17 			provider_id: agent.id,
     18 			receiver_id: agent.id,
     19 			resource_conforms_to_id: Factory.insert!(:resource_specification).id,
     20 			resource_quantity: %{
     21 				has_numerical_value: amount,
     22 				has_unit_id: unit.id,
     23 			},
     24 			has_point_in_time: Factory.now(),
     25 		}, %{name: Factory.str("name")})
     26 	res = EconomicResource.Domain.one!(evt0.resource_inventoried_as_id)
     27 	assert res.previous_event_id == evt0.id
     28 	assert evt0.previous_event_id == nil
     29 	assert Domain.previous(evt0) == nil
     30 
     31 	evt1 = Domain.create!(%{
     32 		action_id: "raise",
     33 		provider_id: agent.id,
     34 		receiver_id: agent.id,
     35 		resource_inventoried_as_id: res.id,
     36 		resource_quantity: %{
     37 			has_numerical_value: amount,
     38 			has_unit_id: unit.id,
     39 		},
     40 		has_point_in_time: Factory.now(),
     41 	})
     42 	res = EconomicResource.Domain.one!(res.id)
     43 	assert res.previous_event_id == evt1.id
     44 	assert evt1.previous_event_id == evt0.id
     45 	id = res.id
     46 	assert %EconomicResource{id: ^id} = Domain.previous(evt1)
     47 
     48 	proc = Factory.insert!(:process)
     49 	evt2 = Domain.create!(%{
     50 		action_id: "produce",
     51 		output_of_id: proc.id,
     52 		provider_id: agent.id,
     53 		receiver_id: agent.id,
     54 		resource_inventoried_as_id: res.id,
     55 		resource_quantity: %{
     56 			has_numerical_value: amount,
     57 			has_unit_id: unit.id,
     58 		},
     59 		has_point_in_time: Factory.now(),
     60 	})
     61 	res = EconomicResource.Domain.one!(res.id)
     62 	assert res.previous_event_id == evt2.id
     63 	assert evt2.previous_event_id == evt1.id
     64 	id = proc.id
     65 	assert %Process{id: ^id} = Domain.previous(evt2)
     66 
     67 	evt3 = Domain.create!(%{
     68 		action_id: "lower",
     69 		provider_id: agent.id,
     70 		receiver_id: agent.id,
     71 		resource_inventoried_as_id: res.id,
     72 		resource_quantity: %{
     73 			has_numerical_value: amount,
     74 			has_unit_id: unit.id,
     75 		},
     76 		has_point_in_time: Factory.now(),
     77 	})
     78 	res = EconomicResource.Domain.one!(res.id)
     79 	assert res.previous_event_id == evt3.id
     80 	assert evt3.previous_event_id == evt2.id
     81 	id = res.id
     82 	assert %EconomicResource{id: ^id} = Domain.previous(evt3)
     83 
     84 	evt4 = Domain.create!(%{
     85 		action_id: "consume",
     86 		input_of_id: Factory.insert!(:process).id,
     87 		provider_id: agent.id,
     88 		receiver_id: agent.id,
     89 		resource_inventoried_as_id: res.id,
     90 		resource_quantity: %{
     91 			has_numerical_value: amount,
     92 			has_unit_id: unit.id,
     93 		},
     94 		has_point_in_time: Factory.now(),
     95 	})
     96 	res = EconomicResource.Domain.one!(res.id)
     97 	assert res.previous_event_id == evt4.id
     98 	assert evt4.previous_event_id == evt3.id
     99 	id = res.id
    100 	assert %EconomicResource{id: ^id} = Domain.previous(evt4)
    101 
    102 	evt5 = Domain.create!(%{
    103 		action_id: "use",
    104 		input_of_id: Factory.insert!(:process).id,
    105 		provider_id: agent.id,
    106 		receiver_id: agent.id,
    107 		resource_inventoried_as_id: res.id,
    108 		resource_quantity: %{
    109 			has_numerical_value: amount,
    110 			has_unit_id: unit.id,
    111 		},
    112 		effort_quantity: %{
    113 			has_numerical_value: Factory.decimal(),
    114 			has_unit_id: Factory.insert!(:unit).id,
    115 		},
    116 		has_point_in_time: Factory.now(),
    117 	})
    118 	res = EconomicResource.Domain.one!(res.id)
    119 	assert res.previous_event_id == evt5.id
    120 	assert evt5.previous_event_id == evt4.id
    121 	id = res.id
    122 	assert %EconomicResource{id: ^id} = Domain.previous(evt5)
    123 
    124 	evt6 = Domain.create!(%{
    125 		action_id: "cite",
    126 		input_of_id: Factory.insert!(:process).id,
    127 		provider_id: agent.id,
    128 		receiver_id: agent.id,
    129 		resource_inventoried_as_id: res.id,
    130 		resource_quantity: %{
    131 			has_numerical_value: amount,
    132 			has_unit_id: unit.id,
    133 		},
    134 		has_point_in_time: Factory.now(),
    135 	})
    136 	res = EconomicResource.Domain.one!(res.id)
    137 	assert res.previous_event_id == evt6.id
    138 	assert evt6.previous_event_id == evt5.id
    139 	id = res.id
    140 	assert %EconomicResource{id: ^id} = Domain.previous(evt6)
    141 
    142 	proc = Factory.insert!(:process)
    143 	evt7 = Domain.create!(%{
    144 		action_id: "pickup",
    145 		input_of_id: proc.id,
    146 		provider_id: agent.id,
    147 		receiver_id: agent.id,
    148 		resource_inventoried_as_id: res.id,
    149 		resource_quantity: %{
    150 			has_numerical_value: amount,
    151 			has_unit_id: unit.id,
    152 		},
    153 		has_point_in_time: Factory.now(),
    154 	})
    155 	res = EconomicResource.Domain.one!(res.id)
    156 	assert res.previous_event_id == evt7.id
    157 	assert evt7.previous_event_id == evt6.id
    158 	id = res.id
    159 	assert %EconomicResource{id: ^id} = Domain.previous(evt7)
    160 
    161 	evt8 = Domain.create!(%{
    162 		action_id: "dropoff",
    163 		output_of_id: proc.id,
    164 		provider_id: agent.id,
    165 		receiver_id: agent.id,
    166 		resource_inventoried_as_id: res.id,
    167 		resource_quantity: %{
    168 			has_numerical_value: amount,
    169 			has_unit_id: unit.id,
    170 		},
    171 		has_point_in_time: Factory.now(),
    172 	})
    173 	res = EconomicResource.Domain.one!(res.id)
    174 	assert res.previous_event_id == evt8.id
    175 	assert evt8.previous_event_id == evt7.id
    176 	id = proc.id
    177 	assert %Process{id: ^id} = Domain.previous(evt8)
    178 
    179 	proc = Factory.insert!(:process)
    180 	evt9 = Domain.create!(%{
    181 		action_id: "accept",
    182 		input_of_id: proc.id,
    183 		provider_id: agent.id,
    184 		receiver_id: agent.id,
    185 		resource_inventoried_as_id: res.id,
    186 		resource_quantity: %{
    187 			has_numerical_value: amount,
    188 			has_unit_id: unit.id,
    189 		},
    190 		has_point_in_time: Factory.now(),
    191 	})
    192 	res = EconomicResource.Domain.one!(res.id)
    193 	assert res.previous_event_id == evt9.id
    194 	assert evt9.previous_event_id == evt8.id
    195 	id = res.id
    196 	assert %EconomicResource{id: ^id} = Domain.previous(evt9)
    197 
    198 	evt10 = Domain.create!(%{
    199 		action_id: "modify",
    200 		output_of_id: proc.id,
    201 		provider_id: agent.id,
    202 		receiver_id: agent.id,
    203 		resource_inventoried_as_id: res.id,
    204 		resource_quantity: %{
    205 			has_numerical_value: amount,
    206 			has_unit_id: unit.id,
    207 		},
    208 		has_point_in_time: Factory.now(),
    209 	})
    210 	res = EconomicResource.Domain.one!(res.id)
    211 	assert res.previous_event_id == evt10.id
    212 	assert evt10.previous_event_id == evt9.id
    213 	id = proc.id
    214 	assert %Process{id: ^id} = Domain.previous(evt10)
    215 
    216 	evt11 = Domain.create!(%{
    217 		action_id: "transferCustody",
    218 		provider_id: agent.id,
    219 		receiver_id: agent.id,
    220 		resource_inventoried_as_id: res.id,
    221 		resource_quantity: %{
    222 			has_numerical_value: amount,
    223 			has_unit_id: unit.id,
    224 		},
    225 		has_point_in_time: Factory.now(),
    226 	})
    227 	res = EconomicResource.Domain.one!(res.id)
    228 	assert res.previous_event_id == evt11.id
    229 	assert evt11.previous_event_id == evt10.id
    230 	id = res.id
    231 	assert %EconomicResource{id: ^id} = Domain.previous(evt11)
    232 
    233 	evt12 = Domain.create!(%{
    234 		action_id: "transferAllRights",
    235 		provider_id: agent.id,
    236 		receiver_id: agent.id,
    237 		resource_inventoried_as_id: res.id,
    238 		resource_quantity: %{
    239 			has_numerical_value: amount,
    240 			has_unit_id: unit.id,
    241 		},
    242 		has_point_in_time: Factory.now(),
    243 	})
    244 	res = EconomicResource.Domain.one!(res.id)
    245 	assert res.previous_event_id == evt12.id
    246 	assert evt12.previous_event_id == evt11.id
    247 	id = res.id
    248 	assert %EconomicResource{id: ^id} = Domain.previous(evt12)
    249 
    250 	evt13 = Domain.create!(%{
    251 		action_id: "transfer",
    252 		provider_id: agent.id,
    253 		receiver_id: agent.id,
    254 		resource_inventoried_as_id: res.id,
    255 		resource_quantity: %{
    256 			has_numerical_value: amount,
    257 			has_unit_id: unit.id,
    258 		},
    259 		has_point_in_time: Factory.now(),
    260 	})
    261 	res = EconomicResource.Domain.one!(res.id)
    262 	assert res.previous_event_id == evt13.id
    263 	assert evt13.previous_event_id == evt12.id
    264 	id = res.id
    265 	assert %EconomicResource{id: ^id} = Domain.previous(evt13)
    266 
    267 	evt14 = Domain.create!(%{
    268 		action_id: "move",
    269 		provider_id: agent.id,
    270 		receiver_id: agent.id,
    271 		resource_inventoried_as_id: res.id,
    272 		resource_quantity: %{
    273 			has_numerical_value: amount,
    274 			has_unit_id: unit.id,
    275 		},
    276 		has_point_in_time: Factory.now(),
    277 	})
    278 	res = EconomicResource.Domain.one!(res.id)
    279 	assert res.previous_event_id == evt14.id
    280 	assert evt14.previous_event_id == evt13.id
    281 	id = res.id
    282 	assert %EconomicResource{id: ^id} = Domain.previous(evt14)
    283 end
    284 end