• AM any object
  • Installation
  • Import
  • Usage
  • API
    • anyObject
    • anyNestedObject
    • extendObject
    • any (experimental)
  • Advanced
    • Generics
  • Use case
    • Flat object
    • Nested object
    • More accurate?
    • More powerful?

AM any object

This library is mock data definition, which removes all unnecessary mock data and type safe for unit testing.

Installation

npm i am-any-object -D

Import

import { anyObject } from "am-any-object";

// or nested object more powerful
import { anyNestedObject } from "am-any-object";

Usage

vi.mocked(fetchFlatData).mockResolvedValue({
  ...anyObject(),

  // only data for unit testing 👍
  firstName: "Taro",
  lastName: "Yamada",
});

expect(name).toBe("Taro Yamada");

If not use anyObject(), you need to write all properties.

vi.mocked(fetchFlatData).mockResolvedValue({
    // data for unit testing
  firstName: "Taro",
  lastName: "Yamada",

  // unnecessary data definition for type error 😢
  id: 1,
  age: 20,
  country: "Japan",
  city: "Tokyo",
});

expect(name).toBe("Taro Yamada");

Why not as any?

vi.mocked(fetchFlatData).mockResolvedValue({
  firstName: "Taro",
  lastName: "Yamada",
  lastName2: "Yamada", // type not safe! 😢
} as any);

...({} as any) is same as any.

vi.mocked(fetchFlatData).mockResolvedValue({
  ...({} as any),

  firstName: "Taro",
  lastName: "Yamada",
  lastName2: "Yamada", // type not safe! 😢
});

API

anyObject

const data = anyObject();

data.id; // undefined
data.age; // undefined
data.ANY_PROPERTY; // undefined

anyNestedObject

const data = anyNestedObject();

data.id; // {}
data.address.city; // {}
data.address.ANY_PROPERTY.ANY_PROPERTY; // {}

const data = anyNestedObject({ address: { city: "Tokyo" } });

data.id; // {}
data.address.city; // "Tokyo"
data.address.ANY_PROPERTY.ANY_PROPERTY; // {}

extendObject

const base = { id: "1", address: { postalCode: "xxx-xxxx" } };
const extended = { address: { city: "Tokyo" } };
const data = extendObject(base, extended);

data.id; // "1"
data.address.postalCode; // "xxx-xxxx"
data.address.city; // "Tokyo"
data.address.OTHER_PROPERTY; // undefined
data.address.OTHER_PROPERTY.OTHER_PROPERTY // Error!

any (experimental)

const data = any();

data.func() // undefined
data.value.func() // undefined
data.items.find() // undefined

Advanced

Generics

import { anyObject } from "am-any-object";

const data = anyObject<{ id: string; age: number }>();

import { anyNestedObject } from "am-any-object";

const data = anyNestedObject<{ id: string; address: { city: string } }>();

Use case

Flat object

type FlatData = {
  id: string;
  age: number;
  firstName: string;
  lastName: string;
  country: string;
  city: string;
};

can use anyObject().

import { anyObject } from "am-any-object";

const data: FlatData = {
  ...anyObject(),

  firstName: "Taro",
  lastName: "Yamada",
};

expect(data.firstName).toBe("Taro");
expect(data.lastName).toBe("Yamada");
expect(data.id).toBeUndefined();

Nested object

export interface NestedData {
  id: string;
  address: {
    country: string;
    city: string;
    postalCode?: string;
    geo: {
      lat: number;
      lng: number;
    };
  };
}

can use anyObject() for nested object.

import { anyObject } from "am-any-object";

const data: NestedData = {
  ...anyObject(),

  address: {
    ...anyObject(),
    geo: anyObject(), // need to define nested object
    postalCode: "xxx-xxxx",
  },
};

expect(data.address.postalCode).toBe("xxx-xxxx");
expect(data.address.geo.lat).toBeUndefined();

can use anyNestedObject() also.

import { anyNestedObject } from "am-any-object";

const data: NestedData = anyNestedObject({
  address: {
    postalCode: "xxx-xxxx",
  },
});

expect(data.address.postalCode).toBe("xxx-xxxx");

// all not defined properties is empty object, be careful!
expect(data.address.geo.lat).toEqual({});

More accurate?

import { extendObject } from "am-any-object";

const fakeData = {
  id: "1",
  address: {
    postalCode: "xxx-xxxx",
  },
};

// it's same deep copy
const data = extendObject(fakeData, {
  address: {
    city: "Tokyo",
  },
});

expect(data.address.postalCode).toBe("xxx-xxxx");
expect(data.address.address).toEqual("Tokyo");

More powerful?

import { any } from "am-any-object";

const data = any();

expect(data.func()).toBeUndefined(); // can call
expect(data.value.func()).toBeUndefined();
expect(data.items.find()).toBeUndefined(); // can use array method