Python faker.Faker() Examples

def create_new_user(requests_session, server, headers):
    # Get a list of groups and grab the ID of the first one
    response = requests_session.get(urljoin(server, "/api/v3/group/"), headers=headers)
    group_id = response.json()["results"][0]["id"]
    group_name = response.json()["results"][0]["name"]
    fake = Faker()

    # Create a user, assigning them to the group we obtained
    user_data = {
        "first_name": fake.first_name(),
        "last_name": fake.last_name(),
        "email": fake.company_email(),
        "groups": {"id": group_id, "name": group_name},
    }
    response = requests_session.post(
        urljoin(server, "/api/v3/user/"), headers=headers, data=user_data
    )

    return {
        "id": response.json()["id"],
        "first_name": response.json()["first_name"],
        "last_name": response.json()["last_name"],
        "group_id": group_id,
    } 

def seed_all(site_name, username):
        """ Seed all catalog data """
        # Make predictable UUIDs using faker
        faker = Faker()
        faker.seed(1234)

        site = Command.get_site(site_name)
        organizations = Command.seed_organizations(site, faker)
        courses = Command.seed_courses(site, organizations, faker)
        course_runs = Command.seed_course_runs(courses, faker)
        programs = Command.seed_programs(site, organizations, course_runs, faker)
        user = Command.get_user(username)
        Command.seed_user_grades(user, course_runs)
        signatories = Command.seed_signatories(organizations)
        course_certificates = Command.seed_course_certificates(site, course_runs, signatories)
        program_certificates = Command.seed_program_certificates(site, programs, signatories)
        Command.seed_user_credentials(user, program_certificates, course_certificates, faker)
        Command.seed_program_cert_records(user, programs, faker)
        pathways = Command.seed_pathways(site, programs, faker)
        Command.seed_user_credit_pathways(user, pathways)
        industry_pathway = Command.seed_industry_pathway(site, programs, faker) 

def test_encrypt_email_address(self):
        """
        Test function `gdpr.encryption.encrypt_email_address` by using email address from Faker lib.
        """
        cleartext = self.faker.email()

        ciphertext = encrypt_email_address(self.encryption_key, cleartext)
        self.assertNotEqual(
            cleartext, ciphertext,
            "The encrypted email address is equal to the original email address."
        )

        decrypted = decrypt_email_address(self.encryption_key, ciphertext)
        self.assertEqual(
            cleartext, decrypted,
            "The decrypted email address is not equal to the original email address."
        ) 

def test_user_create(conf, requests_session, headers):
    # Get a list of groups and grab the ID of the first one
    response = requests_session.get(
        urljoin(conf.getoption("server"), "/api/v3/group/"), headers=headers
    )
    assert response.status_code == 200
    assert_valid_schema(response.json())
    group_id = response.json()["results"][0]["id"]
    group_name = response.json()["results"][0]["name"]
    fake = Faker()

    # Create a user, assigning them to the group we obtained
    user_data = {
        "first_name": fake.first_name(),
        "last_name": fake.last_name(),
        "email": fake.company_email(),
        "groups": {"id": group_id, "name": group_name},
    }
    response = requests_session.post(
        urljoin(conf.getoption("server"), "/api/v3/user/"), headers=headers, data=user_data
    )
    assert response.status_code == 201, response.json()
    assert_valid_schema(response.json()) 

def test_user_update(conf, requests_session, headers):
    # Create a new user
    user_data = create_new_user(requests_session, conf.getoption("server"), headers)

    # Update the user's first and last names
    fake = Faker()
    updated_data = {"first_name": fake.first_name(), "last_name": fake.last_name()}
    response = requests_session.put(
        urljoin(conf.getoption("server"), "/api/v3/user/{}/".format(user_data["id"])),
        headers=headers,
        data=updated_data,
    )
    assert response.status_code == 200
    assert_valid_schema(response.json())

    # Verify they match our expected values
    response = requests_session.get(
        urljoin(conf.getoption("server"), "/api/v3/user/{}".format(user_data["id"])),
        headers=headers,
    )
    assert response.status_code == 200
    assert_valid_schema(response.json())
    assert updated_data["first_name"] == response.json()["first_name"]
    assert updated_data["last_name"] == response.json()["last_name"] 

def __init__(self, tenant, provider, current_month_only=False, config=None):
        """Set up the class."""
        # prevent future whammy:
        assert isinstance(tenant, Tenant), "not a Tenant type"
        assert isinstance(provider, Provider), "not a Provider type"
        assert isinstance(current_month_only, bool), "not a bool type"
        if config:
            assert isinstance(config, FakeAzureConfig), "not a FakeAzureConfig type"

        self.tenant = tenant
        self.provider = provider
        self.current_month_only = current_month_only
        self.config = config if config else FakeAzureConfig()
        self.fake = Faker()
        self.dh = DateHelper()
        self.provider_uuid = provider.uuid
        self.ocp_generator = None

        # generate a list of dicts with unique keys.
        self.period_ranges, self.report_ranges = self.report_period_and_range() 

def test_user_partial_update(conf, requests_session, headers):
    # Create a new user
    user_data = create_new_user(requests_session, conf.getoption("server"), headers)

    # Update the user's first name
    fake = Faker()
    updated_data = {"first_name": fake.first_name()}
    response = requests_session.patch(
        urljoin(conf.getoption("server"), "/api/v3/user/{}/".format(user_data["id"])),
        headers=headers,
        data=updated_data,
    )
    assert response.status_code == 200
    assert_valid_schema(response.json())

    # Verify they match our expected values
    response = requests_session.get(
        urljoin(conf.getoption("server"), "/api/v3/user/{}".format(user_data["id"])),
        headers=headers,
    )
    assert response.status_code == 200
    assert_valid_schema(response.json())
    assert updated_data["first_name"] == response.json()["first_name"] 

def module_config(request):
    fake = Faker()
    return {
        "masters": [
            {
                "minions": [
                    {
                        "config": {
                            "container__config__name": 'minion_{0}_{1}_{2}'.format(fake.word(), fake.word(), os.environ.get('ST_JOB_ID', '')),  # pylint: disable=no-member
                            "container__config__image": (
                                request.config.getini('MINION_IMAGE') or
                                request.config.getini('IMAGE')
                            )
                        }
                    }
                ]
            }
        ]
    } 

def container(request, docker_client, tmpdir_factory):
    fake = Faker()
    obj = ContainerFactory(
        config__name='proxy_container_{0}_{1}_{2}'.format(fake.word(), fake.word(), os.environ.get('ST_JOB_ID', '')),  # pylint: disable=no-member
        config__docker_client=docker_client,
        config__image=request.config.getini('IMAGE'),
        config__environment={
            'ROOT_MOUNTPOINT': '/salt/src',
            'TOASTER_MOUNTPOINT': '/salt-toaster',
            'SALT_TESTS': '/salt/src/salt-2015.8.7/tests',
            'VERSION': 'sles12sp1',
        },
        config__salt_config=None,
        config__host_config=None
    )
    upload(obj, request.config.rootdir.parts()[-2].strpath, '/salt-toaster', tmpdir_factory)
    request.addfinalizer(obj.remove)
    return obj 

def configure():
    from faker import Faker
    fake = Faker()

    settings.configure(
        DATABASES={
            'default': {
                'ENGINE': 'django.db.backends.sqlite3',
                'NAME': ':memory:',
            }
        },
        INSTALLED_APPS=(
            'django_seed',
            'django_nose',
        ),
        TEST_RUNNER = 'django_nose.NoseTestSuiteRunner',
        NOSE_ARGS = [
            '--with-coverage',
            '--cover-package=django_seed',
        ],
        SITE_ID=1,
        SECRET_KEY=fake.sha1(),
    ) 

def proxy_server(request, salt_root, docker_client):
    fake = Faker()
    name = u'proxy_server_{0}_{1}_{2}'.format(fake.word(), fake.word(), os.environ.get('ST_JOB_ID', ''))  # pylint: disable=no-member
    command = 'python -m tests.scripts.proxy_server {0}'.format(PROXY_PORT)
    obj = ContainerFactory(
        config__image=request.config.getini('IMAGE'),
        config__command=command,
        config__name=name,
        config__salt_config=None,
        config__host_config=docker_client.create_host_config(
            binds={
                os.getcwd(): {
                    'bind': "/salt-toaster/",
                    'mode': 'rw'
                }
            }
        ),
        config__volumes=[os.getcwd()]
    )
    request.addfinalizer(obj.remove)
    return obj 

def module_config(request, minion_id, proxy_server):
    fake = Faker()
    proxy_url = 'http://{0}:{1}'.format(proxy_server['ip'], PROXY_PORT)
    return {"masters": [{
        "config": {
            "container__config__salt_config__pillar": {
                "top": {"base": {minion_id: ["proxy"]}},
                "proxy": {
                    "proxy": {"proxytype": "rest_sample", "url": proxy_url}
                }
            }
        },
        "minions": [
            {
                "config": {
                    "container__config__name": 'minion_{0}_{1}_{2}'.format(fake.word(), fake.word(), os.environ.get('ST_JOB_ID', '')),  # pylint: disable=no-member
                    "container__config__salt_config__id": minion_id
                }
            }
        ]
    }]} 

def fake_arn(account_id="", service="fakeservice", region="", resource_separator=":", generate_account_id=False):
    """
    Generate a dummy AWS ARN for testing purposes.

    account_id argument is optional, and will be randomly generated if None.
    Args:
        account_id (str): Optional account ID.
        service (str): Optional service name
        region (str): Optional region
        resource_separator (str): A colon ':' or a forward-slash '/'
        generate_account_id (bool): Whether to generate a random account_id,
                        This will override any account_id that is passed in
    Returns:
        str: A well-formed, randomized ARN.

    """
    if generate_account_id:
        account_id = fake_aws_account_id()
    resource = faker.Faker().name()
    resource_type = faker.Faker().name().replace(" ", "_")
    arn = ("arn:aws:{0}:{1}:{2}:{3}{4}{5}").format(
        service, region, account_id, resource_type, resource_separator, resource
    )
    return arn 

def test_logo_image(self):
        homepage = HomePage.objects.get()
        self.assertIsNone(homepage.logo_image)
        with self.settings(CONFERENCE_ID=self.conference.id):
            # Test that default logo image appears.
            response = self.client.get(homepage.url)
            self.assertContains(response, "/logo.png")
            # Replace default logo with a new image.
            test_logo_name = Faker().uuid4()
            image_file = ImageFile(
                open("conf_site/cms/tests/test-logo.png", "rb"), test_logo_name
            )
            ImageModel = get_image_model()
            image = ImageModel(file=image_file)
            # The image must be saved before it is attached
            # to the homepage.
            image.save()
            homepage.logo_image = image
            homepage.save()
            response = self.client.get(homepage.url)
            self.assertNotContains(response, "/logo.288981a8dfa8.png")
            self.assertContains(response, test_logo_name) 

def setUp(self):
        super().setUp()

        self.faker = Faker()

        USER_EMAIL = self.faker.email()
        USER_PASSWORD = self.faker.password()
        self.user = get_user_model().objects.create_user(
            username=self.faker.profile()["username"],
            email=USER_EMAIL,
            password=USER_PASSWORD,
        )
        speaker = Speaker.objects.create(name=self.faker.name())
        speaker.user = self.user
        speaker.save()

        # Overwrite speaker for this case's proposal.
        self.proposal.speaker = speaker
        self.proposal.save()

        self.assertTrue(
            self.client.login(username=USER_EMAIL, password=USER_PASSWORD)
        ) 

def choice(self, field=None):
        assert field is not None, "The field parameter must be passed to the 'choice' method."
        choices = [c[0] for c in field.choices]
        return self.get_allowed_value(lambda: random.choice(choices), field)

    # Other attributes provided by 'Faker':
    # user_name
    # first_name
    # last_name
    # name
    # email
    # address
    # phonenumber
    # street_address
    # city
    # state
    # zip_code
    # company 

def test_encrypt_text_full_name(self):
        """
        Test function `gdpr.encryption.encrypt_text` by using human full name from Faker lib.
        """
        cleartext = self.faker.name()

        ciphertext = encrypt_text(self.encryption_key, cleartext)
        self.assertNotEqual(
            cleartext, ciphertext,
            "The encrypted name is equal to the original name."
        )

        decrypted = decrypt_text(self.encryption_key, ciphertext)
        self.assertEqual(
            cleartext, decrypted,
            "The decrypted name is not equal to the original name."
        ) 

def test_mass_html_mail(self):
        test_data = list()
        faker = Faker()
        for i in range(random.randint(3, 7)):
            test_data.append((
                faker.sentence(),
                faker.word(), "<strong>{}</strong>".format(faker.word()),
                "test@ps", [],
            ))
            for j in range(random.randint(1, 3)):
                test_data[i][4].append(faker.email())

        result = send_mass_html_mail(test_data)
        self.assertEqual(result, len(test_data))
        self.assertEqual(len(mail.outbox), len(test_data))
        for i in range(len(test_data)):
            for j in range(len(test_data[i][4])):
                self.assertEqual(mail.outbox[i].subject, test_data[i][0])
                self.assertEqual(mail.outbox[i].from_email, settings.DEFAULT_FROM_EMAIL)
                self.assertEqual(mail.outbox[i].to, test_data[i][4]) 

def __init__(self, debug=False, locators=None):
        self.debug = debug
        self._session_records = []
        # Turn off info logging of all http requests
        logging.getLogger("requests.packages.urllib3.connectionpool").setLevel(
            logging.WARN
        )
        if locators:
            lex_locators.update(locators)
        else:
            self._init_locators()

        self._faker = faker.Faker("en_US")
        try:
            self.builtin.set_global_variable("${faker}", self._faker)
        except RobotNotRunningError:
            # this only happens during unit tests, and we don't care.
            pass 

def set_faker_locale(self, locale):
        """Set the locale for fake data

        This sets the locale for all calls to the ``Faker`` keyword
        and ``${faker}`` variable. The default is en_US

        For a list of supported locales see
        [https://faker.readthedocs.io/en/master/locales.html|Localized Providers]
        in the Faker documentation.

        Example

        | Set Faker Locale    fr_FR
        | ${french_address}=  Faker  address

        """
        try:
            self._faker = faker.Faker(locale)
        except AttributeError:
            raise Exception(f"Unknown locale for fake data: '{locale}'") 

def test_score(self):
        fake = Faker()
        fake.seed(0)
        pipeline = Pipeline(
            steps=[
                (
                    "vectorizer",
                    CountVectorizer(stop_words="english", max_features=25, max_df=0.9),
                ),
                ("ae", SDAETransformer(dimensions=[25, 10, 2], finetune_epochs=1)),
            ]
        )
        param_grid = {
            "ae__pretrain_epochs": [1, 2, 3],
        }
        search = GridSearchCV(
            pipeline, param_grid, iid=False, cv=2, return_train_score=False
        )
        search.fit([fake.text() for _ in range(10)]) 

def test_get_user_api_data(self):
        """ Verify the method retrieves data from the User API and caches it. """
        username = Faker().user_name()
        data = {
            'username': username,
        }
        url = '{root}accounts/{username}'.format(root=self.site_configuration.user_api_url, username=username)
        responses.add(responses.GET, url, body=json.dumps(data), content_type=JSON, status=200)
        self.mock_access_token_response()

        actual = self.site_configuration.get_user_api_data(username)
        self.assertEqual(actual, data)
        self.assertEqual(len(responses.calls), 2)

        # Verify the data is cached
        responses.reset()
        actual = self.site_configuration.get_user_api_data(username)
        self.assertEqual(actual, data)
        self.assertEqual(len(responses.calls), 0) 

def generate_fake(count=100, **kwargs):
        """Generate a number of fake users for testing."""
        from sqlalchemy.exc import IntegrityError
        from random import seed, choice
        from faker import Faker

        fake = Faker()
        roles = Role.query.all()

        seed()
        for i in range(count):
            u = User(
                first_name=fake.first_name(),
                last_name=fake.last_name(),
                email=fake.email(),
                password='password',
                confirmed=True,
                role=choice(roles),
                **kwargs)
            db.session.add(u)
            try:
                db.session.commit()
            except IntegrityError:
                db.session.rollback() 

def function_random(param):
    """
    Call `Faker <https://github.com/joke2k/faker>`_ and return it's result. Is used to generate random data.
    F.e. ::

        - echo: {from: '{{ random("email") }}', to: one.output}

    :param param: Faker's provider name.
    """
    fake = Faker()
    for modname, importer in module_utils.get_submodules_of('faker.providers'):  # add all known providers
        fake.add_provider(importer.find_module(modname).load_module(modname))
    if hasattr(fake, param):
        return getattr(fake, param)()
    else:
        raise ValueError('Unknown param to randomize: ' + param) 

def fake_profile(self, ctx, locale=None):
        """Profile."""
        em = discord.Embed(title="Fake Profile")
        order = [
            'name', 'sex',
            'birthdate', 'blood_group',
            'ssn', 'username',
            'job', 'company',
            'mail',
            'residence',
            'website'
        ]
        profile = Faker(locale).profile()
        for k in order:
            v = profile.get(k)
            if v is None:
                v = '__'
            elif isinstance(v, list):
                v = '\n'.join(v)
            em.add_field(name=k.title(), value=v)
        await self.bot.say(embed=em) 

def generate_fake(count=100, **kwargs):
        """Generate a number of fake users for testing."""
        from sqlalchemy.exc import IntegrityError
        from random import seed, choice
        from faker import Faker

        fake = Faker()
        roles = Role.query.all()

        seed()
        for i in range(count):
            u = User(
                first_name=fake.first_name(),
                last_name=fake.last_name(),
                email=fake.email(),
                password='password',
                confirmed=True,
                role=choice(roles),
                **kwargs)
            db.session.add(u)
            try:
                db.session.commit()
            except IntegrityError:
                db.session.rollback() 

def setUp(self):
        super(TestGZip, self).setUp()
        fake = Faker()

        class TestView(APIView):
            @gzip()
            def get(self, request, *args, **kwargs):
                """Example to check `Content-Encoding` header is set to 'gzip'."""
                return Response(status=200, data=fake.text())

        class SubClassTestView(TestView):
            def get(self, request, *args, **kwargs):
                """Example to check that no status is set after overriding inherited endpoints."""
                return Response(status=200, data=fake.text())

        self.view = TestView.as_view()
        self.subclass_view = SubClassTestView.as_view()
        self.factory = RequestFactory() 

def _load_from_yaml(self, filename):
        if not self.env:
            self.env = Environment(loader=PackageLoader('tests',
                                                        'model_fixtures'))
            faker = Faker()
            faker.seed_instance(1234)
            self.env.globals['faker'] = faker

        template = self.env.get_template(filename)
        fixture_data = yaml.load(template.render(), Loader=yaml.FullLoader)

        class_name = filename[:filename.rfind('.')]
        for identifier_id, data in fixture_data.items():
            # FIXME check for dups
            self.class_name_lookup[identifier_id] = class_name
            self.model_fixtures[identifier_id] = data 

def generate_file(filename, generated_type):
    print("Generating " + filename)
    with open(filename, 'w', newline='') as csvfile:
        writer = csv.writer(csvfile, delimiter=',',
                            quotechar='"', quoting=csv.QUOTE_MINIMAL)
        generated_set = set()
        fake = Faker()
        fake.add_provider(internet)
        fake.add_provider(date_time)
        soFar = 0
        total = 2000000
        while len(generated_set) != total:
            indicator, csv_line = generate_indicator(fake, generated_type)
            if indicator in generated_set:
                continue
            generated_set.add(indicator)
            writer.writerow(csv_line)
            soFar += 1
            if (soFar % 10000 == 0):
                print(f"Finished {soFar} out of {total}")

    print("Finished" + filename) 

def create_demo_fixtures():
    fake = Faker()
    name = fake.name()

    # have username be demo-username, so demos-users are easy to tell
    username = 'demo-{name}'.format(name=name)
    username = slugify(username)

    # since these are demo accounts, just set the username/pass the same
    # so this is a really weird bug since you'd wonder why this would be a get_or_create
    # but faker doesn't always generate fake names in celery instances ...
    user, _ = User.objects.get_or_create(username=username)

    # create a log of this person as a demo user, otherwise we would never be able to tell if someone is a demo or not!
    _, created = DemoUserLog.objects.get_or_create(user=user)
    if not created:
        return

    fixtures_builder = DemoHistoricalDataBuilder(user, periods_back=180)
    fixtures_builder.create_historical_fixtures()