What Would be a Design Based Approach

[kudla]

Hi.
I'm trying to test some subjectFunction. I've created a helper which constructs a test case lifecycle

const pureTestCase(caseInputData, subjectFunction) => caseOutputContext

And on a set of different caseInputData I would like to run a similar set of isolated assertions (I.e. each assertion should fail/succeed individually)

const inputCases = [...]
caseInputs.forEach(caseInput => {
  const caseOutput =  pureTestCase(caseInput, subjectFunction) 
  test(assertionA, caseOutput)
  test(assertionB, caseOutput)
  test(assertionC, caseOutput)
})

So is there any better design based approach to organize such a flow?
I'was thinking of using beforeEach but it doesn't resolve caseInputData injection.

Is it possible e.g. to compose macro chains somehow sharing the context

caseInputs.forEach(caseInput => {
  test(pureTestCase, assertionA,  caseInput)
  test(pureTestCase, assertionB, caseInput)
  test(pureTestCase, assertionC, caseInput)
})

is it possible to fork the same pureTestCase output context

caseInputs.forEach(caseInput => {
  test(pureTestCase,  caseInput, [assertionA, assertionB, assertionC])
})

and still run assertionA, assertionB, assertionC individually?

Or is there any other better solution in my case?

Thx!

[novemberborn]

This is a little abstract for me, or at least at this point in the morning. Could you give a more concrete example?

[kudla]

As I understand the macros are tended to be a reusable logic code.
And my intention is to compose two different macros.

My subject function produces input signals aggregation in time.

So I plan the testing logic to split in two layers

• based on case input data simulates signal inputs to a subject I.e. [runtime]
• produce assertions based on statistical analysis of subject aggregated outputs signals E.g. [avg] [rates] [max] etc.
  [runtime], [avg], [rates], [max] etc. are the same (reusable) pure functions to case input data. And the statistical assertions are the same

And logically I'd like to run something like this

And taking to account that [runtime] is pretty heavy and the same way is pure even like this

And still every assertion to be failed/succeed individually.

I can see it may be organized just with the simple composition of functions. But I was curious can I do this some how composing a macros set and piping t.context among them?

My apologies if an explanation is complicated.
Thx.

[novemberborn]

Within a test, AVA currently reports only the first failing assertion. It sounds like you want different tests for each output, so data 1 - avg, data 1 - rates etc.

I'd then define macros for avg, rates and max, perhaps with a title generating function, and then declare the tests in a loop:

for (const {label, data} of [{label: 'data 1', data: /*…*/0 }]) {
  test(label, avg)
  test(label, rates)
  test(label, max)
}

How you want to compose that with the runtime is up to you, perhaps test(label, avg, data) and have avg take care of it, or test(label, avg, runtime, data) or test(label, avg, () => runtime(data)).

[kudla]

Cool. Thanx Mark.
Actually test(label, avg, () => runtime(data)) is something I eventually came with up as well.

And initially I was wondering about something like this test(label, avg, runtime, data)
Is this approach tend avg it self to care making runtime(data) call based on the its arguments? Or can test do this behind the stage so that runtime does the job and shares the result over t.context and next avg just address it self to t.context only? E.g. something like middleware pipeline.

[novemberborn]

Functional composition is a better approach IMHO, though if you pass t around then yes you could communicate over t.context it just seems like it'd be really confusing to me.

You could also make runtime a macro:

test(label, runtime, data, avg)

where avg is just a function that receives t and whatever it needs for its assertions.

[kudla]

Thank you Mark!