Dictionary symbol and iteration index

[adamxi]

Hey, I'm really unsure how to go about constructing an arbitrary which can model the following interface:

interface CountrySettings {
  defaultCountry: string,

  countries: Record<string, {
    order: number,
    active: boolean
  }>
}

An example model of this interface could be:

const countries: CountrySettings = {
  defaultCountry: "GB",
  countries:{
    "GB": {
      order: 0,
      active: true,
    },
    "GR": {
      order: 1,
      active: false,
    },
    "FR": {
      order: 2,
      active: true
    }
  }
}

Ideally I would like to write the following:

function fakerToArb<T>(fakerGen: () => T) {
  return fc
    .integer()
    .noBias()
    .noShrink()
    .map(seed => {
      faker.seed(seed);
      return fakerGen();
    });
}

const countryCodeArb = fakerToArb(faker.address.countryCode);

const countrySettingsArb = {
  default: countryCodeArb,
  
  [countryCodeArb]: {
    order: fc.constant(0),
    active: fc.constant(true)
  },

  ...fc.dictionary(
    countryCodeArb,
    (index) => fc.record({
      order: fc.constant(index),
      active: fc.constant(true)
    }),
    { minKeys: 0, maxKeys: 2 }
  )
};

So the immediate issues I encounter is that I would like to use the countryCodeArb as a symbol for the first record entry, which I can't.
Next, I would like to access the index of the dictionary iteration so that I can assign this index to the order.
I also tried solutions involving fc.integer({min:0, max:2}).map(num => ...) so that I could get the index of the iteration, but then I struggle to get these arbitraries back into a Record structure.

I feel that I'm very limited in how I can actually use fast-check to construct records, but maybe I'm not using the library correctly?

[dubzzz]

You may try something like:

function fakerToArb(fakerGen) {
  return fc
    .integer()
    .noBias()
    .noShrink()
    .map(seed => {
      faker.seed(seed);
      return fakerGen();
    });
}

const countryCodeArb = fakerToArb(faker.address.countryCode);

const countrySettingsArb = fc.uniqueArray(
  fc.record({ code: countryCodeArb, active: fc.boolean() }),
  { minLength: 1, selector: country => country.code },
)
  .map(countries => {
    return {
      default: countries[0].code,
      ...Object.fromEntries(
        countries.map((country, index) => [country.code, { order: index, active: country.active }])
      )
    };
  });

[dubzzz]

Why did I went for that construct?

Your data-structure comes with various not that random things:

• default cannot be any country code but must be one of the known ones
• order is 0 for default
• order goes from 0 to N-1 and represent the "index" of the country among all the available ones, it cannot take any random integral value

The third constraint requires to have some kind of array of the structure, in other words we needed something like:

fc.array(countryCodeArb)
  .map(countries => Object.fromEntries(countries.map((code, index) => [code, {order: index}])))

Due to the first constraint, we cannot really build default outside. It needs to be the one with the order=0. So we somehow need to build it with others:

fc.array(countryCodeArb)
  .map(countries => ({
    default: countries[0],
    ...Object.fromEntries(countries.map((code, index) => [code, {order: index}])
  })))

And finally countries are not just codes, they have meta data attached to them. So we need to build them too by changing fc.array(countryCodeArb) into:

fc.array(fc.record({
  code: countryCodeArb,
  meta1: ...,
})

[dubzzz]

Alternatively you may have tried gen. Even if less optimal for shrinking, it (in theory) offers an API closer to usual random.

Here is how your code would have been done with it:

function fakerToArb(fakerGen) {
  return fc
    .integer()
    .noBias()
    .noShrink()
    .map(seed => {
      faker.seed(seed);
      return fakerGen();
    });
}

const countryCodeArbBuilder = () => fakerToArb(faker.address.countryCode);

fc.assert(fc.property(fc.gen(), g => {
  const numCountries = g(fc.nat, {max: 10});
  const defaultCountry = g(countryCodeArbBuilder);
  const countries = {
    default: defaultCountry,
    [defaultCountry]: { order: 0, active: true },
  };
  for (let index = 1 ; index < numCountries ; ++index) {
    let other = g(countryCodeArbBuilder);
    while (other in countries) {
      other = g(countryCodeArbBuilder);
    }
    countries[other] = { order: index, active: g(fc.boolean) };
  }
  // your data is ready,
  // your test goes here!!!
  console.log(countries);
}));

⚠️ It has one big issue: it makes the assumptions that we will always be able to build numCountries (capped to 10) different countries. And actually if we want to rewrite it without this need, we should use an uniqueArray builder, and we somehow reach back our map approach.

[adamxi]

You may try something like:

function fakerToArb(fakerGen) {
  return fc
    .integer()
    .noBias()
    .noShrink()
    .map(seed => {
      faker.seed(seed);
      return fakerGen();
    });
}

const countryCodeArb = fakerToArb(faker.address.countryCode);

const countrySettingsArb = fc.uniqueArray(
  fc.record({ code: countryCodeArb, active: fc.boolean() }),
  { minLength: 1, selector: country => country.code },
)
  .map(countries => {
    return {
      default: countries[0].code,
      ...Object.fromEntries(
        countries.map((country, index) => [country.code, { order: index, active: country.active }])
      )
    };
  });

Interesting approach - thanks for taking you time to write it.
This looks like it could work out just fine.

This kind of key-value map is a common data structure we use in our application. And for testing, we therefore often need a custom key-getter function based on realistic random data, and a custom value-getter function with access to the object key and iteration index of the key-value map.
Something that normally in JavaScript could be done with Array reduce or a simple for loop.

I think better support for generating this kind data structure in fast-check would be very helpful.

Anyway, I would try and take your approach and generalize it as a helper function for our needs - thanks.