This comes from Python's parsing rules.

Why?

When you write this:

class UserFactory(factory.django.DjangoModelFactory):
    ⋮
    traffic_source = random.choice(['XYZ', 'ABC', '123', '456'])

Python will execute the following steps:

1. Read the class declaration body;

2. Reach the line traffic_source = random.choice(['XYZ', 'ABC', '123', '456']);

3. Evaluate the call to random.choice, which might return 'ABC';

4. Once each line of the class body has been read (and its function calls evaluated), create the class:

   UserFactory = type(
       name='UserFactory',
       bases=[factory.django.DjangoModelFactory],
       {'traffic_source': 'ABC', … },
    )
   

As you can see, the call to random.choice is performed only once, when parsing the class declaration.

This is, basically, the reason for all the factory.XXX declarations: they yield an object that will only execute its specific rules when building an instance from the factory.

So, what should you do?

Here, you should use:

• Either factory.Faker using Faker's random_element provider;
• Or factory.fuzzy.FuzzyChoice:

class UserFactory(factory.django.DjangoModelFactory):
    ⋮
    traffic_source = factory.Faker('random_element', elements=['XYZ', 'ABC', '123', '456'])
    alt_traffic_source = factory.fuzzy.FuzzyChoice(['XYZ', 'ABC', '123', '456'])

The main difference between factory.Faker('random_choices') and factory.fuzzy.FuzzyChoices is that factory.fuzzy.FuzzyChoices supports lazily evaluating generators; this is useful if you want to choose from a queryset:

• factory.Faker('random_element', elements=Company.objects.all()) will perform a DB query at import time;
• factory.fuzzy.FuzzyChoice(Company.objects.all()) will only query the DB the first time UserFactory.create() is called.

Since Faker v6.3.0, the following 2 methods should do the trick:

1. faker.helpers.arrayElement (doc)
2. faker.helpers.arrayElements (doc)

You'll not need a FuzzyAttribute.

You can either restrict the values possible and only give the int value of each product type to FuzzyChoice by doing something like this:

from factory import fuzzy

PRODUCT_IDS = [x[0] for x in IceCreamProduct.PRODUCT_TYPES]
class IceCreamProductFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = IceCreamProduct

    type = fuzzy.FuzzyChoice(PRODUCT_IDS)

It should do the work.

Please be aware that fuzzy module has been deprecated recently, see Fuzzy Attributes Documentation, you may want to use a LazyFunction instead.

Update 2023 for v8

Now moved to https://github.com/faker-js/faker, they changed it again:

faker.number.int(options: number | {
  max: number,
  min: number
} = {}): number
faker.number.int() // 2900970162509863
faker.number.int(100) // 52
faker.number.int({ min: 1000000 }) // 2900970162509863
faker.number.int({ max: 100 }) // 42
faker.number.int({ min: 10, max: 100 }) // 57

source: https://fakerjs.dev/api/number.html#int

Update 2021

Latest versions changed location of the function from faker.random.number to faker.datatype.number, https://github.com/Marak/faker.js/issues/1156

Original answer

You need to give an object to the function:

faker.datatype.number({
    'min': 10,
    'max': 50
});

So if you just pass a number, it will set it as the max value. The min value is 0 by default.

This is the implementation of the number function :

this.number = function (options) {

    if (typeof options === "number") {
      options = {
        max: options
      };
    }

    options = options || {};

    if (typeof options.min === "undefined") {
      options.min = 0;
    }

    if (typeof options.max === "undefined") {
      options.max = 99999;
    }
    if (typeof options.precision === "undefined") {
      options.precision = 1;
    }

    // Make the range inclusive of the max value
    var max = options.max;
    if (max >= 0) {
      max += options.precision;
    }

    var randomNumber = options.precision * Math.floor(
      mersenne.rand(max / options.precision, options.min / options.precision));

    return randomNumber;

  }