Goldziher

export const UserDTOFactory = new FixtureFactory<UserDTO>(() => {
    const { profile, ...user } = UserFactory.buildSync();
    return {
        ...user,
        ...profile,
    };
});

Goldziher

import { UserDTOFactory } from '@shared/factories/User.dto.factory';
import { render } from '@testing-library/react';
import UserProfile from '@frontend/pages/user-profile';

describe('UserProfile', () => {
    it('matches snapshot', () => {
        const user = UserDTOFactory.fixtureSync(
            __dirname + '/UserProfile.spec.json',
        )
        const { container } = render(<UserProfile user={user} /> );

Goldziher

import { UserDTO } from '@shared/dto/user.dto';
import axios, { AxiosInstance } from 'axios';

class BackendClient {
    private instance: AxiosInstance;

    constructor() {
        this.instance = axios.create({
            baseURL: process.env.BACKEND_API_URL,
            headers: {

Goldziher

    // ...
    
    getUser = async (id: string): Promise<UserDTO> => {
        const { data } = await UserDTOFactory.build({ id });
        return data;
    };

Goldziher

import { Meta } from '@storybook/react';
import { UserDTO } from '@shared/dto/User.dto';
import { UserDTOFactory } from '@shared/factories/User.dto.factory';
import React from 'react';
import UserProfile from '@frontend/pages/user-profile';

export default {
    title: 'Users/Profile',
    component: UserProfile,
} as Meta;

Goldziher

import { useEffect, useRef } from 'react';

export function useInterval(
    callback: (clearInterval: () => void) => any,
    delay: number | null,
): () => void {
    const idRef = useRef<null | number>(null);

    const clearInterval = () => {
        if (idRef.current) {

Goldziher

from itertools import islice
from typing import Iterator, Sequence, TypeVar

T = TypeVar("T")


def chunk(sequence: Sequence[T], size: int) -> Iterator[list[T]]:
    """given a sequence, return an iterator of lists of the given size"""
    return iter(lambda: list(islice(iter(sequence), size)), [])

Goldziher

function isDuck(value) {
    return !!(
        value &&
        typeof value === 'object' &&
        typeof Reflect.get(value, 'quack') === 'function'
    );
}

Goldziher

interface Duck {
    quack(): string;
}

function isDuck(value: unknown): value is Duck {
    return !!(
        value &&
        typeof value === 'object' &&
        typeof Reflect.get(value, 'quack') === 'function'
    );

Goldziher

from typing import Any

def is_duck(value: Any) -> bool:
  try:
    value.quack()
    return True
  except (Attribute, ValueError):
    return False