level_0
int64 0
10k
| index
int64 0
0
| repo_id
stringlengths 22
152
| file_path
stringlengths 41
203
| content
stringlengths 11
11.5M
|
|---|---|---|---|---|
7,860 | 0 | petrpan-code/airbnb/visx/packages/visx-mock-data | petrpan-code/airbnb/visx/packages/visx-mock-data/test/letterFrequency.test.ts | import { letterFrequency } from '../src';
describe('mocks/letterFrequency', () => {
test('it should be defined', () => {
expect(letterFrequency).toBeDefined();
});
test('it should be an array', () => {
expect(letterFrequency.length).toBeDefined();
});
test('it should return [{ letter, frequency }]', () => {
const data = letterFrequency;
expect(data[0].letter).toBeDefined();
expect(data[0].frequency).toBeDefined();
expect(typeof data[0].letter).toBe('string');
expect(typeof data[0].frequency).toBe('number');
});
});
|
7,861 | 0 | petrpan-code/airbnb/visx/packages/visx-mock-data | petrpan-code/airbnb/visx/packages/visx-mock-data/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
7,873 | 0 | petrpan-code/airbnb/visx/packages/visx-network | petrpan-code/airbnb/visx/packages/visx-network/test/Graph.test.tsx | import { Graph } from '../src';
describe('Graph', () => {
test('Graph should be defined', () => {
expect(Graph).toBeDefined();
});
});
|
7,874 | 0 | petrpan-code/airbnb/visx/packages/visx-network | petrpan-code/airbnb/visx/packages/visx-network/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
7,887 | 0 | petrpan-code/airbnb/visx/packages/visx-pattern | petrpan-code/airbnb/visx/packages/visx-pattern/test/Pattern.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { Pattern } from '../src';
describe('<Pattern />', () => {
test('it should be defined', () => {
expect(Pattern).toBeDefined();
});
test('it should require an id prop', () => {
expect(() =>
shallow(
// @ts-expect-error allow invalid props
<Pattern width={4} height={4}>
<rect />
</Pattern>,
),
).toThrow();
});
test('it should require a width prop', () => {
expect(() =>
shallow(
// @ts-expect-error allow invalid props
<Pattern id="test" height={4}>
<rect />
</Pattern>,
),
).toThrow();
});
test('it should require a height prop', () => {
expect(() =>
shallow(
// @ts-expect-error allow invalid props
<Pattern id="test" width={4}>
<rect />
</Pattern>,
),
).toThrow();
});
test('it should require children', () => {
// @ts-expect-error allow invalid prop
expect(() => shallow(<Pattern id="test" width={4} />)).toThrow();
});
});
|
7,888 | 0 | petrpan-code/airbnb/visx/packages/visx-pattern | petrpan-code/airbnb/visx/packages/visx-pattern/test/PatternCircles.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { PatternCircles } from '../src';
describe('<PatternCircles />', () => {
test('it should be defined', () => {
expect(PatternCircles).toBeDefined();
});
test('it should require an id prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternCircles width={4} height={4} />)).toThrow();
});
test('it should require a width prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternCircles id="test" height={4} />)).toThrow();
});
test('it should require a height prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternCircles id="test" width={4} />)).toThrow();
});
test('it should render a rect background if background prop defined', () => {
const wrapper = shallow(<PatternCircles id="test" height={4} width={4} background="blue" />);
expect(wrapper.find('rect')).toHaveLength(1);
});
test('it should not render a rect background if no background prop', () => {
const wrapper = shallow(<PatternCircles id="test" height={4} width={4} />);
expect(wrapper.find('rect')).toHaveLength(0);
});
});
|
7,889 | 0 | petrpan-code/airbnb/visx/packages/visx-pattern | petrpan-code/airbnb/visx/packages/visx-pattern/test/PatternHexagons.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { PatternHexagons } from '../src';
describe('<PatternHexagons />', () => {
test('it should be defined', () => {
expect(PatternHexagons).toBeDefined();
});
test('it should require an id prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternHexagons width={4} height={4} />)).toThrow();
});
test('it should require a height prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternHexagons id="test" width={4} />)).toThrow();
});
});
|
7,890 | 0 | petrpan-code/airbnb/visx/packages/visx-pattern | petrpan-code/airbnb/visx/packages/visx-pattern/test/PatternLines.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { PatternLines } from '../src';
import { PatternOrientationType } from '../src/constants';
import { pathForOrientation } from '../src/patterns/Lines';
describe('<PatternLines />', () => {
test('it should be defined', () => {
expect(PatternLines).toBeDefined();
});
test('it should require an id prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternLines width={4} height={4} />)).toThrow();
});
test('it should require a width prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternLines id="test" height={4} />)).toThrow();
});
test('it should require a height prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternLines id="test" width={4} />)).toThrow();
});
test('it should render a rect background if background prop defined', () => {
const wrapper = shallow(<PatternLines id="test" height={4} width={4} background="blue" />);
expect(wrapper.find('rect')).toHaveLength(1);
});
test('it should not render a rect background if no background prop', () => {
const wrapper = shallow(<PatternLines id="test" height={4} width={4} />);
expect(wrapper.find('rect')).toHaveLength(0);
});
test('it should render only the specified pattern lines', () => {
const size = 4;
const orientation: PatternOrientationType[] = ['diagonal', 'diagonalRightToLeft'];
const renderedPaths = orientation.map((o) =>
pathForOrientation({ orientation: o, height: size }),
);
const wrapper = shallow(
<PatternLines id="test" height={size} width={size} orientation={orientation} />,
);
expect(wrapper.find('path')).toHaveLength(2);
expect(wrapper.find('path').map((path) => path.prop('d'))).toEqual(renderedPaths);
});
});
|
7,891 | 0 | petrpan-code/airbnb/visx/packages/visx-pattern | petrpan-code/airbnb/visx/packages/visx-pattern/test/PatternPath.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { PatternPath } from '../src';
describe('<PatternPath />', () => {
test('it should be defined', () => {
expect(PatternPath).toBeDefined();
});
test('it should require an id prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternPath width={4} height={4} />)).toThrow();
});
test('it should require a width prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternPath id="test" height={4} />)).toThrow();
});
test('it should require a height prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternPath id="test" width={4} />)).toThrow();
});
test('it should render a rect background if background prop defined', () => {
const wrapper = shallow(<PatternPath id="test" height={4} width={4} background="blue" />);
expect(wrapper.find('rect')).toHaveLength(1);
});
test('it should not render a rect background if no background prop', () => {
const wrapper = shallow(<PatternPath id="test" height={4} width={4} />);
expect(wrapper.find('rect')).toHaveLength(0);
});
});
|
7,892 | 0 | petrpan-code/airbnb/visx/packages/visx-pattern | petrpan-code/airbnb/visx/packages/visx-pattern/test/PatternWaves.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { PatternWaves } from '../src';
describe('<PatternWaves />', () => {
test('it should be defined', () => {
expect(PatternWaves).toBeDefined();
});
test('it should require an id prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternWaves width={4} height={4} />)).toThrow();
});
test('it should require a width prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternWaves id="test" height={4} />)).toThrow();
});
test('it should require a height prop', () => {
// @ts-expect-error allow invalid props
expect(() => shallow(<PatternWaves id="test" width={4} />)).toThrow();
});
});
|
7,893 | 0 | petrpan-code/airbnb/visx/packages/visx-pattern | petrpan-code/airbnb/visx/packages/visx-pattern/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
7,902 | 0 | petrpan-code/airbnb/visx/packages/visx-point | petrpan-code/airbnb/visx/packages/visx-point/test/point.test.ts | import { Point } from '../src';
describe('Point', () => {
test('Point should be defined', () => {
expect(Point).toBeDefined();
});
test('constructor defaults to 0,0', () => {
const p = new Point({});
expect(p.x).toBe(0);
expect(p.y).toBe(0);
});
test('constructor sets x,y', () => {
const p = new Point({ x: 3, y: 4 });
expect(p.x).toBe(3);
expect(p.y).toBe(4);
});
test('value()', () => {
const c = { x: 3, y: 4 };
const p = new Point(c);
expect(p.value()).toEqual(c);
});
test('toArray()', () => {
const c = { x: 3, y: 4 };
const p = new Point(c);
expect(p.toArray()).toEqual([c.x, c.y]);
});
});
|
7,903 | 0 | petrpan-code/airbnb/visx/packages/visx-point | petrpan-code/airbnb/visx/packages/visx-point/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
7,915 | 0 | petrpan-code/airbnb/visx/packages/visx-react-spring | petrpan-code/airbnb/visx/packages/visx-react-spring/test/AnimatedAxis.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { scaleLinear } from '@visx/scale';
import { AnimatedAxis } from '../src';
describe('AnimatedAxis', () => {
it('should be defined', () => {
expect(AnimatedAxis).toBeDefined();
});
it('should not throw', () => {
expect(() =>
shallow(<AnimatedAxis scale={scaleLinear({ domain: [0, 10], range: [0, 10] })} />),
).not.toThrow();
});
});
|
7,916 | 0 | petrpan-code/airbnb/visx/packages/visx-react-spring | petrpan-code/airbnb/visx/packages/visx-react-spring/test/AnimatedGridColumns.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { scaleLinear } from '@visx/scale';
import { AnimatedGridColumns } from '../src';
describe('AnimatedGridColumns', () => {
it('should be defined', () => {
expect(AnimatedGridColumns).toBeDefined();
});
it('should not throw', () => {
expect(() =>
shallow(
<AnimatedGridColumns
height={10}
scale={scaleLinear({ domain: [0, 10], range: [0, 10] })}
/>,
),
).not.toThrow();
});
});
|
7,917 | 0 | petrpan-code/airbnb/visx/packages/visx-react-spring | petrpan-code/airbnb/visx/packages/visx-react-spring/test/AnimatedGridRows.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { scaleLinear } from '@visx/scale';
import { AnimatedGridRows } from '../src';
describe('AnimatedGridRows', () => {
it('should be defined', () => {
expect(AnimatedGridRows).toBeDefined();
});
it('should not throw', () => {
expect(() =>
shallow(
<AnimatedGridRows width={10} scale={scaleLinear({ domain: [0, 10], range: [0, 10] })} />,
),
).not.toThrow();
});
});
|
7,918 | 0 | petrpan-code/airbnb/visx/packages/visx-react-spring | petrpan-code/airbnb/visx/packages/visx-react-spring/test/AnimatedTicks.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { scaleLinear } from '@visx/scale';
import { AnimatedTicks } from '../src';
describe('AnimatedTicks', () => {
it('should be defined', () => {
expect(AnimatedTicks).toBeDefined();
});
it('should render tickComponent defined', () => {
const wrapper = shallow(
<AnimatedTicks
hideTicks={false}
horizontal={false}
orientation="bottom"
tickComponent={() => <text>Test Component</text>}
scale={scaleLinear({ domain: [0, 10], range: [0, 10] })}
tickLabelProps={[]}
ticks={[
{
from: { x: 0, y: 0 },
to: { x: 0, y: 5 },
value: 0,
index: 0,
formattedValue: '0',
},
]}
/>,
);
expect(wrapper.text()).toBe('Test Component');
});
it('should not throw', () => {
expect(() =>
shallow(
<AnimatedTicks
hideTicks={false}
horizontal={false}
orientation="bottom"
scale={scaleLinear({ domain: [0, 10], range: [0, 10] })}
tickLabelProps={[]}
ticks={[
{ from: { x: 0, y: 0 }, to: { x: 0, y: 5 }, value: 0, index: 0, formattedValue: '0' },
]}
/>,
),
).not.toThrow();
});
});
|
7,919 | 0 | petrpan-code/airbnb/visx/packages/visx-react-spring | petrpan-code/airbnb/visx/packages/visx-react-spring/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
7,920 | 0 | petrpan-code/airbnb/visx/packages/visx-react-spring | petrpan-code/airbnb/visx/packages/visx-react-spring/test/useLineTransitionConfig.test.tsx | import React from 'react';
import { scaleLinear } from '@visx/scale';
import { shallow } from 'enzyme';
import useLineTransitionConfig from '../src/spring-configs/useLineTransitionConfig';
const scale = scaleLinear({ domain: [0, 10], range: [0, 10] });
const invertedScale = scaleLinear({ domain: [0, 10], range: [10, 0] });
const verticalLine = { from: { x: 0, y: 0 }, to: { x: 0, y: 5 } };
const verticalLineMax = { from: { x: 8, y: 0 }, to: { x: 8, y: 5 } };
describe('useLineTransitionConfig', () => {
it('should be defined', () => {
expect(useLineTransitionConfig).toBeDefined();
});
it('should return react-spring config with from, enter, update, leave keys', () => {
expect.assertions(1);
function HookTest() {
const config = useLineTransitionConfig({ scale, animateXOrY: 'x' });
expect(config).toMatchObject({
from: expect.any(Function),
enter: expect.any(Function),
update: expect.any(Function),
leave: expect.any(Function),
});
return null;
}
shallow(<HookTest />);
});
it('should animate from scale min', () => {
expect.assertions(2);
function HookTest() {
const config = useLineTransitionConfig({
scale,
animateXOrY: 'x',
animationTrajectory: 'min',
});
const invertedConfig = useLineTransitionConfig({
scale: invertedScale,
animateXOrY: 'y',
animationTrajectory: 'min',
});
expect(config.from(verticalLine).fromX).toBe(0);
expect(invertedConfig.from(verticalLine).fromY).toBe(10);
return null;
}
shallow(<HookTest />);
});
it('should animate from scale max', () => {
expect.assertions(2);
function HookTest() {
const config = useLineTransitionConfig({
scale,
animateXOrY: 'x',
animationTrajectory: 'max',
});
const invertedConfig = useLineTransitionConfig({
scale: invertedScale,
animateXOrY: 'y',
animationTrajectory: 'max',
});
expect(config.from(verticalLine).fromX).toBe(10);
expect(invertedConfig.from(verticalLine).fromY).toBe(0);
return null;
}
shallow(<HookTest />);
});
it('should animate from outside', () => {
expect.assertions(2);
function HookTest() {
const config = useLineTransitionConfig({
scale,
animateXOrY: 'x',
animationTrajectory: 'outside',
});
expect(config.from(verticalLine).fromX).toBe(0);
expect(config.from(verticalLineMax).fromX).toBe(10);
return null;
}
shallow(<HookTest />);
});
it('should animate from center', () => {
expect.assertions(1);
function HookTest() {
const config = useLineTransitionConfig({
scale,
animateXOrY: 'x',
animationTrajectory: 'center',
});
expect(config.from(verticalLine).fromX).toBe(5);
return null;
}
shallow(<HookTest />);
});
});
|
7,931 | 0 | petrpan-code/airbnb/visx/packages/visx-responsive | petrpan-code/airbnb/visx/packages/visx-responsive/test/ParentSize.test.tsx | import React from 'react';
import { ResizeObserver } from '@juggle/resize-observer';
import { render } from '@testing-library/react';
import { ParentSize } from '../src';
describe('<ParentSize />', () => {
it('should be defined', () => {
expect(ParentSize).toBeDefined();
});
it('does not throw', () => {
const wrapper = render(
<ParentSize resizeObserverPolyfill={ResizeObserver}>
{() => <div data-testid="test" />}
</ParentSize>,
);
expect(wrapper.findByTestId('test')).not.toBeNull();
});
});
|
7,932 | 0 | petrpan-code/airbnb/visx/packages/visx-responsive | petrpan-code/airbnb/visx/packages/visx-responsive/test/ScaleSVG.test.tsx | import React from 'react';
import { render } from '@testing-library/react';
import '@testing-library/jest-dom';
import { ScaleSVG } from '../src';
describe('<ScaleSVG />', () => {
test('it should be defined', () => {
expect(ScaleSVG).toBeDefined();
});
test('it should expose its ref via an innerRef prop', () => {
const fakeRef = React.createRef<SVGSVGElement>();
const { container } = render(<ScaleSVG innerRef={fakeRef} />);
const SVGElement = container.querySelector('svg');
expect(fakeRef.current).toContainElement(SVGElement);
});
});
|
7,933 | 0 | petrpan-code/airbnb/visx/packages/visx-responsive | petrpan-code/airbnb/visx/packages/visx-responsive/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
7,934 | 0 | petrpan-code/airbnb/visx/packages/visx-responsive | petrpan-code/airbnb/visx/packages/visx-responsive/test/withParentSize.test.tsx | import React from 'react';
import { render } from '@testing-library/react';
import { ResizeObserver } from '@juggle/resize-observer';
import '@testing-library/jest-dom';
import { withParentSize } from '../src';
type ComponentProps = {
parentWidth?: number;
parentHeight?: number;
};
function Component({ parentWidth, parentHeight }: ComponentProps) {
return <div data-testid="Component" style={{ width: parentWidth, height: parentHeight }} />;
}
describe('withParentSize', () => {
test('it should be defined', () => {
expect(withParentSize).toBeDefined();
});
test('it should pass parentWidth and parentHeight props to its child', () => {
const HOC = withParentSize(Component, ResizeObserver);
const { getByTestId } = render(<HOC initialWidth={200} initialHeight={200} />);
const RenderedComponent = getByTestId('Component');
expect(RenderedComponent).toHaveStyle('width: 200px; height: 200px');
});
});
|
7,935 | 0 | petrpan-code/airbnb/visx/packages/visx-responsive | petrpan-code/airbnb/visx/packages/visx-responsive/test/withScreenSize.test.ts | import { withScreenSize } from '../src';
describe('withScreenSize', () => {
test('it should be defined', () => {
expect(withScreenSize).toBeDefined();
});
});
|
7,985 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/createScale.test.ts | import { createScale } from '../src';
describe('createScale()', () => {
it('linear', () => {
const scale = createScale({ type: 'linear', domain: [0, 10], range: [2, 4] });
expect(scale(5)).toBe(3);
});
it('fallbacks to linear if type is not defined', () => {
const scale = createScale({ domain: [0, 10], range: [2, 4] });
expect(scale(5)).toBe(3);
});
it('log', () => {
const scale = createScale({
type: 'log',
base: 2,
domain: [2, 8],
range: [1, 3],
});
expect(scale(4)?.toFixed(2)).toBe('2.00');
});
it('pow', () => {
const scale = createScale({ type: 'pow', exponent: 2, domain: [1, 3], range: [2, 18] });
expect(scale(2)).toBe(8);
});
it('sqrt', () => {
const scale = createScale({ type: 'sqrt', domain: [1, 9], range: [1, 3] });
expect(scale(4)).toBe(2);
});
it('symlog', () => {
const scale = createScale({ type: 'symlog', domain: [1, 9], range: [1, 3], constant: 2 });
expect(scale(4)?.toFixed(2)).toBe('2.07');
});
it('time', () => {
const scale = createScale({
type: 'time',
domain: [new Date(2020, 0, 1), new Date(2020, 0, 10)],
range: [1, 10],
});
expect(scale(new Date(2020, 0, 4))).toBe(4);
});
it('utc', () => {
const scale = createScale({
type: 'utc',
domain: [new Date(Date.UTC(2020, 0, 1)), new Date(Date.UTC(2020, 0, 10))],
range: [1, 10],
});
expect(scale(new Date(Date.UTC(2020, 0, 4)))).toBe(4);
});
it('quantile', () => {
const scale = createScale({ type: 'quantile', domain: [1, 3, 5, 7], range: [0, 10] });
expect(scale(2)).toBe(0);
});
it('quantize', () => {
const scale = createScale({ type: 'quantize', domain: [1, 10], range: ['red', 'green'] });
expect(scale(2)).toBe('red');
expect(scale(6)).toBe('green');
});
it('threshold', () => {
const scale = createScale({
type: 'threshold',
domain: [0, 1] as number[],
range: ['red', 'white', 'green'],
});
expect(scale(-1)).toBe('red');
expect(scale(0)).toBe('white');
expect(scale(0.5)).toBe('white');
expect(scale(1)).toBe('green');
expect(scale(1000)).toBe('green');
});
it('ordinal', () => {
const scale = createScale({ type: 'ordinal', domain: ['pig', 'cat'], range: ['red', 'green'] });
expect(scale('pig')).toBe('red');
expect(scale('cat')).toBe('green');
});
it('point', () => {
const scale = createScale({
type: 'point',
domain: ['a', 'b', 'c'],
range: [1.1, 3.5],
round: true,
});
expect(scale('a')).toBe(1);
expect(scale('b')).toBe(2);
expect(scale('c')).toBe(3);
});
it('band', () => {
const scale = createScale({
type: 'band',
domain: ['a', 'b', 'c'],
range: [1.1, 3.5],
round: false,
});
expect(scale('a')).toBe(1.1);
expect(scale('b')).toBe(1.9);
expect(scale('c')).toBe(2.7);
});
it('invalid type', () => {
// @ts-expect-error
expect(createScale({ type: 'invalid' })).toBeDefined();
});
});
|
7,986 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scaleBand.test.ts | import { scaleBand } from '../src';
describe('scaleBand', () => {
it('should be defined', () => {
expect(scaleBand).toBeDefined();
});
it('set domain', () => {
const domain = [0, 350];
const scale = scaleBand({ domain });
expect(scale.domain()).toEqual(domain);
});
it('set range', () => {
const scale = scaleBand({ range: [2, 3] });
expect(scale.range()).toEqual([2, 3]);
});
it('set align', () => {
expect(scaleBand({ align: 0.5 }).align()).toBe(0.5);
});
it('set padding', () => {
expect(scaleBand({ padding: 0.3 }).padding()).toBe(0.3);
});
it('set paddingInner', () => {
expect(scaleBand({ paddingInner: 0.7 }).paddingInner()).toBe(0.7);
});
it('set paddingOuter', () => {
expect(scaleBand({ paddingOuter: 0.7 }).paddingOuter()).toBe(0.7);
});
describe('set round', () => {
it('true', () => {
const scale = scaleBand({ domain: ['a', 'b', 'c'], range: [1.1, 3.5], round: true });
expect(scale('a')).toBe(2);
expect(scale('b')).toBe(2);
expect(scale('c')).toBe(2);
});
it('false', () => {
const scale = scaleBand({ domain: ['a', 'b', 'c'], range: [1.1, 3.5], round: false });
expect(scale('a')).toBe(1.1);
expect(scale('b')).toBe(1.9);
expect(scale('c')).toBe(2.7);
});
});
});
|
7,987 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scaleLinear.test.ts | import mockConsole from 'jest-mock-console';
import { scaleLinear } from '../src';
describe('scaleLinear()', () => {
it('should be defined', () => {
expect(scaleLinear).toBeDefined();
});
it('set domain', () => {
const domain = [1, 2];
expect(scaleLinear({ domain: [1, 2] }).domain()).toEqual(domain);
});
it('set range', () => {
const range = [1, 2];
expect(scaleLinear({ range: [1, 2] }).range()).toEqual(range);
});
it('set reverse', () => {
expect(scaleLinear({ reverse: true }).range()).toEqual([1, 0]);
expect(scaleLinear({ range: [1, 2], reverse: true }).range()).toEqual([2, 1]);
});
describe('set clamp', () => {
it('true', () => {
const scale = scaleLinear({ clamp: true });
expect(scale(10)).toBe(1);
});
it('false', () => {
const scale = scaleLinear({ clamp: false });
expect(scale(10)).toBe(10);
});
});
describe('set (color) interpolate', () => {
it('string', () => {
const scale = scaleLinear({
domain: [0, 10],
range: ['#ff0000', '#000000'],
interpolate: 'lab',
});
expect(scale(5)).toBe('rgb(122, 27, 11)');
});
it('config object', () => {
const scale = scaleLinear({
domain: [0, 10],
range: ['#ff0000', '#000000'],
interpolate: {
type: 'rgb',
},
});
expect(scale(5)).toBe('rgb(128, 0, 0)');
});
it('config object with gamma', () => {
const scale = scaleLinear({
domain: [0, 10],
range: ['#ff0000', '#000000'],
interpolate: {
type: 'rgb',
gamma: 0.9,
},
});
expect(scale(5)).toBe('rgb(118, 0, 0)');
});
});
describe('set nice', () => {
it('true', () => {
const scale = scaleLinear({ domain: [0.1, 0.91], nice: true });
expect(scale.domain()).toEqual([0.1, 1]);
});
it('false', () => {
const scale = scaleLinear({ domain: [0.1, 0.91], nice: false });
expect(scale.domain()).toEqual([0.1, 0.91]);
});
});
describe('set round', () => {
it('true', () => {
const scale = scaleLinear({ domain: [0, 10], range: [0, 10], round: true });
expect(scale(2.2)).toBe(2);
expect(scale(2.6)).toBe(3);
});
it('false', () => {
const scale = scaleLinear({ domain: [0, 10], range: [0, 10], round: false });
expect(scale(2.2)).toBe(2.2);
expect(scale(2.6)).toBe(2.6);
});
it('warns if do both interpolate and round', () => {
const restoreConsole = mockConsole();
scaleLinear({
domain: [0, 10],
range: [0, 10],
interpolate: 'hsl',
round: true,
});
expect(console.warn).toHaveBeenCalledTimes(1);
restoreConsole();
});
});
describe('set zero', () => {
it('true', () => {
expect(scaleLinear({ domain: [1, 2], zero: true }).domain()).toEqual([0, 2]);
expect(scaleLinear({ domain: [-2, -1], zero: true }).domain()).toEqual([-2, 0]);
expect(scaleLinear({ domain: [1, -2], zero: true }).domain()).toEqual([1, -2]);
expect(scaleLinear({ domain: [-2, 3], zero: true }).domain()).toEqual([-2, 3]);
});
it('false', () => {
expect(scaleLinear({ domain: [1, 2], zero: false }).domain()).toEqual([1, 2]);
expect(scaleLinear({ domain: [-2, -1], zero: false }).domain()).toEqual([-2, -1]);
expect(scaleLinear({ domain: [-2, 3], zero: false }).domain()).toEqual([-2, 3]);
});
});
});
|
7,988 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scaleLog.test.ts | import { scaleLog } from '../src';
describe('scaleLog()', () => {
it('should be defined', () => {
expect(scaleLog).toBeDefined();
});
it('set domain', () => {
const domain = [1, 2];
expect(scaleLog({ domain: [1, 2] }).domain()).toEqual(domain);
});
it('set range', () => {
const range = [1, 2];
expect(scaleLog({ range: [1, 2] }).range()).toEqual(range);
});
it('set base', () => {
expect(scaleLog({ base: 2 }).base()).toBe(2);
});
describe('set clamp', () => {
it('true', () => {
const scale = scaleLog({ range: [1, 2], clamp: true });
expect(scale(100)).toBe(2);
});
it('false', () => {
const scale = scaleLog({ range: [1, 2], clamp: false });
expect(scale(100)).toBe(3);
});
});
it('set (color) interpolate', () => {
const scale = scaleLog({
domain: [1, 100],
range: ['#ff0000', '#000000'],
interpolate: 'lab',
});
expect(scale(10)).toBe('rgb(122, 27, 11)');
});
describe('set nice', () => {
it('true', () => {
const scale = scaleLog({ domain: [0.1, 0.91], nice: true });
expect(scale.domain()).toEqual([0.1, 1]);
});
it('false', () => {
const scale = scaleLog({ domain: [0.1, 0.91], nice: false });
expect(scale.domain()).toEqual([0.1, 0.91]);
});
});
describe('set round', () => {
it('true', () => {
const scale = scaleLog({ domain: [1, 10], range: [1, 10], round: true });
expect(scale(2.2)).toBe(4);
});
it('false', () => {
const scale = scaleLog({ domain: [1, 10], range: [1, 10], round: false });
expect(scale(5)?.toFixed(2)).toBe('7.29');
});
});
});
|
7,989 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scaleOrdinal.test.ts | import { scaleOrdinal } from '../src';
describe('scaleOrdinal', () => {
it('should be defined', () => {
expect(scaleOrdinal).toBeDefined();
});
it('set domain', () => {
const domain = ['noodle', 'burger'];
const scale = scaleOrdinal({ domain });
expect(scale.domain()).toEqual(domain);
});
it('set range', () => {
const range = ['red', 'green'];
const scale = scaleOrdinal({ range });
expect(scale.range()).toEqual(range);
});
it('set unknown', () => {
const scale = scaleOrdinal({ domain: ['noodle', 'burger'], unknown: 'green' });
expect(scale('sandwich')).toBe('green');
});
});
|
7,990 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scalePoint.test.ts | import { scalePoint } from '../src';
describe('scalePoint', () => {
it('should be defined', () => {
expect(scalePoint).toBeDefined();
});
it('set domain', () => {
const domain = [0, 350];
const scale = scalePoint({ domain });
expect(scale.domain()).toEqual(domain);
});
it('set range', () => {
const scale = scalePoint({ range: [2, 3] });
expect(scale.range()).toEqual([2, 3]);
});
it('set reverse', () => {
expect(scalePoint({ reverse: true }).range()).toEqual([1, 0]);
expect(scalePoint({ range: [1, 2], reverse: true }).range()).toEqual([2, 1]);
});
it('set align', () => {
expect(scalePoint({ align: 0.5 }).align()).toBe(0.5);
});
it('set padding', () => {
expect(scalePoint({ padding: 0.5 }).padding()).toBe(0.5);
});
describe('set round', () => {
it('true', () => {
const scale = scalePoint({ domain: ['a', 'b', 'c'], range: [1.1, 3.5], round: true });
expect(scale('a')).toBe(1);
expect(scale('b')).toBe(2);
expect(scale('c')).toBe(3);
});
it('false', () => {
const scale = scalePoint({ domain: ['a', 'b', 'c'], range: [1.1, 3.5], round: false });
expect(scale('a')).toBe(1.1);
expect(scale('b')).toBe(2.3);
expect(scale('c')).toBe(3.5);
});
});
});
|
7,991 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scalePower.test.ts | import { scalePower } from '../src';
describe('scalePower()', () => {
it('should be defined', () => {
expect(scalePower).toBeDefined();
});
it('set domain', () => {
const domain = [1, 2];
expect(scalePower({ domain: [1, 2] }).domain()).toEqual(domain);
});
it('set range', () => {
const range = [1, 2];
expect(scalePower({ range: [1, 2] }).range()).toEqual(range);
});
it('set exponent', () => {
expect(scalePower({ exponent: 3 }).exponent()).toBe(3);
});
describe('set clamp', () => {
it('true', () => {
const scale = scalePower({ clamp: true });
expect(scale(10)).toBe(1);
});
it('false', () => {
const scale = scalePower({ clamp: false });
expect(scale(10)).toBe(10);
});
});
it('set (color) interpolate', () => {
const scale = scalePower({
domain: [0, 10],
range: ['#ff0000', '#000000'],
interpolate: 'lab',
});
expect(scale(5)).toBe('rgb(122, 27, 11)');
});
describe('set nice', () => {
it('true', () => {
const scale = scalePower({ domain: [0.1, 0.91], nice: true });
expect(scale.domain()).toEqual([0.1, 1]);
});
it('false', () => {
const scale = scalePower({ domain: [0.1, 0.91], nice: false });
expect(scale.domain()).toEqual([0.1, 0.91]);
});
});
describe('set round', () => {
it('true', () => {
const scale = scalePower({ domain: [0, 10], range: [0, 10], round: true });
expect(scale(2.2)).toBe(2);
expect(scale(2.6)).toBe(3);
});
it('false', () => {
const scale = scalePower({ domain: [0, 10], range: [0, 10], round: false });
expect(scale(2.2)).toBe(2.2);
expect(scale(2.6)).toBe(2.6);
});
});
describe('set zero', () => {
it('true', () => {
expect(scalePower({ domain: [1, 2], zero: true }).domain()).toEqual([0, 2]);
expect(scalePower({ domain: [-2, -1], zero: true }).domain()).toEqual([-2, 0]);
expect(scalePower({ domain: [-2, 3], zero: true }).domain()).toEqual([-2, 3]);
});
it('false', () => {
expect(scalePower({ domain: [1, 2], zero: false }).domain()).toEqual([1, 2]);
expect(scalePower({ domain: [-2, -1], zero: false }).domain()).toEqual([-2, -1]);
expect(scalePower({ domain: [-2, 3], zero: false }).domain()).toEqual([-2, 3]);
});
});
});
|
7,992 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scaleQuantile.test.ts | import { scaleQuantile } from '../src';
describe('scaleQuantile', () => {
it('should be defined', () => {
expect(scaleQuantile).toBeDefined();
});
it('set domain', () => {
const domain = [0, 350];
const scale = scaleQuantile({ domain });
expect(scale.domain()).toEqual(domain);
});
it('set range', () => {
const range = [2, 3];
const scale = scaleQuantile({ range });
expect(scale.range()).toEqual(range);
});
});
|
7,993 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scaleQuantize.test.ts | import { scaleQuantize } from '../src';
describe('scaleQuantize', () => {
it('should be defined', () => {
expect(scaleQuantize).toBeDefined();
});
it('set domain', () => {
const domain = [1, 2];
expect(scaleQuantize({ domain: [1, 2] }).domain()).toEqual(domain);
});
it('set range', () => {
const range = [1, 2];
expect(scaleQuantize({ range: [1, 2] }).range()).toEqual(range);
});
describe('set nice', () => {
it('true', () => {
const scale = scaleQuantize({ domain: [0.1, 0.91], nice: true });
expect(scale.domain()).toEqual([0.1, 1]);
});
it('false', () => {
const scale = scaleQuantize({ domain: [0.1, 0.91], nice: false });
expect(scale.domain()).toEqual([0.1, 0.91]);
});
});
describe('set zero', () => {
it('true', () => {
expect(scaleQuantize({ domain: [1, 2], zero: true }).domain()).toEqual([0, 2]);
expect(scaleQuantize({ domain: [-2, -1], zero: true }).domain()).toEqual([-2, 0]);
expect(scaleQuantize({ domain: [-2, 3], zero: true }).domain()).toEqual([-2, 3]);
});
it('false', () => {
expect(scaleQuantize({ domain: [1, 2], zero: false }).domain()).toEqual([1, 2]);
expect(scaleQuantize({ domain: [-2, -1], zero: false }).domain()).toEqual([-2, -1]);
expect(scaleQuantize({ domain: [-2, 3], zero: false }).domain()).toEqual([-2, 3]);
});
});
});
|
7,994 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scaleRadial.test.ts | import { scaleRadial } from '../src';
describe('sclaeRadial()', () => {
it('should be defined', () => {
expect(scaleRadial).toBeDefined();
});
it('set domain', () => {
const domain = [1, 2];
expect(scaleRadial({ domain: [1, 2] }).domain()).toEqual(domain);
});
it('set range', () => {
const range = [1, 2];
expect(scaleRadial({ range: [1, 2] }).range()).toEqual(range);
});
it('set unknown', () => {
const scale = scaleRadial({ domain: [0, 10], unknown: 'green' });
// coerce to make TS happy
expect(scale('sandwich' as unknown as number)).toBe('green');
});
describe('set clamp', () => {
it('true', () => {
const scale = scaleRadial({ clamp: true });
expect(scale(10)).toBe(1);
});
it('false', () => {
const scale = scaleRadial({ clamp: false });
expect(scale(10)).toEqual(Math.sqrt(10));
});
});
describe('set nice', () => {
it('true', () => {
const scale = scaleRadial({ domain: [0.1, 0.91], nice: true });
expect(scale.domain()).toEqual([0.1, 1]);
});
it('false', () => {
const scale = scaleRadial({ domain: [0.1, 0.91], nice: false });
expect(scale.domain()).toEqual([0.1, 0.91]);
});
});
describe('set round', () => {
it('true', () => {
const scale = scaleRadial({ round: true });
expect(scale(10)).toEqual(Math.round(Math.sqrt(10)));
expect(scale(2.6)).toEqual(Math.round(Math.sqrt(2.6)));
});
it('false', () => {
const scale = scaleRadial({ round: false });
expect(scale(10)).toEqual(Math.sqrt(10));
expect(scale(2.6)).toEqual(Math.sqrt(2.6));
});
});
});
|
7,995 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scaleSqrt.test.ts | import { scaleSqrt } from '../src';
describe('scaleSqrt()', () => {
it('should be defined', () => {
expect(scaleSqrt).toBeDefined();
});
it('set domain', () => {
const domain = [1, 2];
expect(scaleSqrt({ domain: [1, 2] }).domain()).toEqual(domain);
});
it('set range', () => {
const range = [1, 2];
expect(scaleSqrt({ range: [1, 2] }).range()).toEqual(range);
});
it('exponent is 0.5', () => {
expect(scaleSqrt({}).exponent()).toBe(0.5);
});
describe('set clamp', () => {
it('true', () => {
const scale = scaleSqrt({ clamp: true });
expect(scale(10)).toBe(1);
});
it('false', () => {
const scale = scaleSqrt<number>({ clamp: false });
expect(scale(10)?.toFixed(2)).toBe('3.16');
});
});
it('set (color) interpolate', () => {
const scale = scaleSqrt({
domain: [0, 10],
range: ['#ff0000', '#000000'],
interpolate: 'lab',
});
expect(scale(5)).toBe('rgb(73, 23, 9)');
});
describe('set nice', () => {
it('true', () => {
const scale = scaleSqrt({ domain: [0.1, 0.91], nice: true });
expect(scale.domain()).toEqual([0.1, 1]);
});
it('false', () => {
const scale = scaleSqrt({ domain: [0.1, 0.91], nice: false });
expect(scale.domain()).toEqual([0.1, 0.91]);
});
});
describe('set round', () => {
it('true', () => {
const scale = scaleSqrt({ domain: [0, 4], range: [0, 2], round: true });
expect(scale(3)).toBe(2);
});
it('false', () => {
const scale = scaleSqrt({ domain: [0, 4], range: [0, 2], round: false });
expect(scale(3)?.toFixed(2)).toBe('1.73');
});
});
describe('set zero', () => {
it('true', () => {
expect(scaleSqrt({ domain: [1, 2], zero: true }).domain()).toEqual([0, 2]);
expect(scaleSqrt({ domain: [-2, -1], zero: true }).domain()).toEqual([-2, 0]);
expect(scaleSqrt({ domain: [-2, 3], zero: true }).domain()).toEqual([-2, 3]);
});
it('false', () => {
expect(scaleSqrt({ domain: [1, 2], zero: false }).domain()).toEqual([1, 2]);
expect(scaleSqrt({ domain: [-2, -1], zero: false }).domain()).toEqual([-2, -1]);
expect(scaleSqrt({ domain: [-2, 3], zero: false }).domain()).toEqual([-2, 3]);
});
});
});
|
7,996 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scaleSymlog.test.ts | import { scaleSymlog } from '../src';
describe('scaleSymlog', () => {
it('should be defined', () => {
expect(scaleSymlog).toBeDefined();
});
it('set domain', () => {
const domain = [1, 2];
expect(scaleSymlog({ domain: [1, 2] }).domain()).toEqual(domain);
});
it('set range', () => {
const range = [1, 2];
expect(scaleSymlog({ range: [1, 2] }).range()).toEqual(range);
});
describe('set clamp', () => {
it('true', () => {
const scale = scaleSymlog({ clamp: true });
expect(scale(10)).toBe(1);
});
it('false', () => {
const scale = scaleSymlog<number>({ clamp: false });
expect(scale(10)?.toFixed(2)).toBe('3.46');
});
});
it('set constant', () => {
const constant = 2;
const scale = scaleSymlog({ constant });
expect(scale.constant()).toEqual(constant);
});
describe('set nice', () => {
it('true', () => {
const scale = scaleSymlog({ domain: [0.1, 0.91], nice: true });
expect(scale.domain()).toEqual([0.1, 1]);
});
it('false', () => {
const scale = scaleSymlog({ domain: [0.1, 0.91], nice: false });
expect(scale.domain()).toEqual([0.1, 0.91]);
});
});
describe('set zero', () => {
it('true', () => {
expect(scaleSymlog({ domain: [1, 2], zero: true }).domain()).toEqual([0, 2]);
expect(scaleSymlog({ domain: [-2, -1], zero: true }).domain()).toEqual([-2, 0]);
expect(scaleSymlog({ domain: [-2, 3], zero: true }).domain()).toEqual([-2, 3]);
});
it('false', () => {
expect(scaleSymlog({ domain: [1, 2], zero: false }).domain()).toEqual([1, 2]);
expect(scaleSymlog({ domain: [-2, -1], zero: false }).domain()).toEqual([-2, -1]);
expect(scaleSymlog({ domain: [-2, 3], zero: false }).domain()).toEqual([-2, 3]);
});
});
describe('set round', () => {
it('true', () => {
expect(scaleSymlog({ domain: [1, 3], round: true })(2)).toBe(1);
});
it('false', () => {
expect((scaleSymlog({ domain: [1, 3], round: false })(2) as number).toFixed(3)).toBe('0.585');
});
});
});
|
7,997 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scaleThreshold.test.ts | import { scaleThreshold } from '../src';
describe('scaleThreshold', () => {
it('should be defined', () => {
expect(scaleThreshold).toBeDefined();
});
it('set domain', () => {
const domain = [0, 350];
const scale = scaleThreshold({ domain });
expect(scale.domain()).toEqual(domain);
});
it('set range', () => {
const range = [2, 3];
const scale = scaleThreshold({ range });
expect(scale.range()).toEqual(range);
});
});
|
7,998 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scaleTime.test.ts | import TimezoneMock from 'timezone-mock';
import { scaleTime } from '../src';
describe('scaleTime()', () => {
let domain: [Date, Date];
let unniceDomain: [Date, Date];
beforeAll(() => {
TimezoneMock.register('US/Pacific');
domain = [new Date(2020, 0, 1), new Date(2020, 0, 10)];
unniceDomain = [new Date(2020, 0, 1), new Date(2020, 0, 9, 20)];
});
afterAll(() => {
TimezoneMock.unregister();
});
it('should be defined', () => {
expect(scaleTime).toBeDefined();
});
it('set domain', () => {
expect(scaleTime({ domain }).domain()).toEqual(domain);
});
it('set range', () => {
const range = [1, 2];
expect(scaleTime({ range: [1, 2] }).range()).toEqual(range);
});
describe('set clamp', () => {
it('true', () => {
const scale = scaleTime({ domain, range: [0, 10], clamp: true });
expect(scale(new Date(2019, 11, 31))).toBe(0);
});
it('false', () => {
const scale = scaleTime({ domain, range: [0, 10], clamp: false });
expect(scale(new Date(2019, 11, 31))?.toFixed(2)).toBe('-1.11');
});
});
it('set (color) interpolate', () => {
const scale = scaleTime({
domain,
range: ['#ff0000', '#000000'],
interpolate: 'lab',
});
expect(scale(new Date(2020, 0, 5))).toBe('rgb(136, 28, 11)');
});
describe('set nice', () => {
it('true', () => {
const scale = scaleTime({
domain: unniceDomain,
nice: true,
});
expect(scale.domain()).toEqual(domain);
});
it('false', () => {
const scale = scaleTime({ domain: unniceDomain, nice: false });
expect(scale.domain()).toEqual(unniceDomain);
});
it('number', () => {
const scale = scaleTime({ domain: unniceDomain, nice: 5 });
expect(scale.domain()).toEqual([new Date(2020, 0, 1), new Date(2020, 0, 11)]);
});
it('time unit string', () => {
const scale = scaleTime({ domain: unniceDomain, nice: 'hour' });
expect(scale.domain()).toEqual(unniceDomain);
});
it('nice object', () => {
const scale = scaleTime({ domain: unniceDomain, nice: { interval: 'hour', step: 3 } });
expect(scale.domain()).toEqual([new Date(2020, 0, 1), new Date(2020, 0, 9, 21)]);
});
it('invalid nice object', () => {
const scale = scaleTime({ domain: unniceDomain, nice: { interval: 'hour', step: NaN } });
expect(scale.domain()).toEqual(unniceDomain);
});
});
describe('set round', () => {
it('true', () => {
const scale = scaleTime({
domain,
range: [1, 5],
round: true,
});
expect(scale(new Date(2020, 0, 5))).toBe(3);
});
it('false', () => {
const scale = scaleTime({
domain,
range: [1, 5],
round: false,
});
expect(scale(new Date(2020, 0, 5))?.toFixed(2)).toBe('2.78');
});
});
});
|
7,999 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/scaleUtc.test.ts | import TimezoneMock from 'timezone-mock';
import { scaleUtc } from '../src';
describe('scaleUtc()', () => {
let domain: [Date, Date];
let unniceDomain: [Date, Date];
beforeAll(() => {
TimezoneMock.register('US/Pacific');
domain = [new Date(Date.UTC(2020, 0, 1)), new Date(Date.UTC(2020, 0, 10))];
unniceDomain = [new Date(Date.UTC(2020, 0, 1)), new Date(Date.UTC(2020, 0, 9, 20))];
});
afterAll(() => {
TimezoneMock.unregister();
});
it('should be defined', () => {
expect(scaleUtc).toBeDefined();
});
it('set domain', () => {
expect(scaleUtc({ domain }).domain()).toEqual(domain);
});
it('set range', () => {
const range = [1, 2];
expect(scaleUtc({ range: [1, 2] }).range()).toEqual(range);
});
describe('set clamp', () => {
it('true', () => {
const scale = scaleUtc({ domain, range: [0, 10], clamp: true });
expect(scale(new Date(Date.UTC(2019, 11, 31)))).toBe(0);
});
it('false', () => {
const scale = scaleUtc({ domain, range: [0, 10], clamp: false });
expect(scale(new Date(Date.UTC(2019, 11, 31)))?.toFixed(2)).toBe('-1.11');
});
});
it('set (color) interpolate', () => {
const scale = scaleUtc({
domain,
range: ['#ff0000', '#000000'],
interpolate: 'lab',
});
expect(scale(new Date(Date.UTC(2020, 0, 5)))).toBe('rgb(136, 28, 11)');
});
describe('set nice', () => {
it('true', () => {
const scale = scaleUtc({
domain: unniceDomain,
nice: true,
});
expect(scale.domain()).toEqual(domain);
});
it('false', () => {
const scale = scaleUtc({ domain: unniceDomain, nice: false });
expect(scale.domain()).toEqual(unniceDomain);
});
it('number', () => {
const scale = scaleUtc({ domain: unniceDomain, nice: 5 });
expect(scale.domain()).toEqual([
new Date(Date.UTC(2020, 0, 1)),
new Date(Date.UTC(2020, 0, 11)),
]);
});
it('time unit string', () => {
const scale = scaleUtc({ domain: unniceDomain, nice: 'hour' });
expect(scale.domain()).toEqual(unniceDomain);
});
it('nice object', () => {
const scale = scaleUtc({ domain: unniceDomain, nice: { interval: 'hour', step: 3 } });
expect(scale.domain()).toEqual([
new Date(Date.UTC(2020, 0, 1)),
new Date(Date.UTC(2020, 0, 9, 21)),
]);
});
});
describe('set round', () => {
it('true', () => {
const scale = scaleUtc({
domain,
range: [1, 5],
round: true,
});
expect(scale(new Date(Date.UTC(2020, 0, 5)))).toBe(3);
});
it('false', () => {
const scale = scaleUtc({
domain,
range: [1, 5],
round: false,
});
expect(scale(new Date(Date.UTC(2020, 0, 5)))?.toFixed(2)).toBe('2.78');
});
});
});
|
8,000 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
8,001 | 0 | petrpan-code/airbnb/visx/packages/visx-scale | petrpan-code/airbnb/visx/packages/visx-scale/test/updateScale.test.ts | import TimezoneMock from 'timezone-mock';
import {
updateScale,
scaleLinear,
scaleLog,
scalePower,
scaleSqrt,
scaleSymlog,
scaleTime,
scaleUtc,
scaleQuantile,
scaleOrdinal,
scalePoint,
scaleBand,
scaleQuantize,
scaleThreshold,
} from '../src';
describe('updateScale', () => {
it('should be defined', () => {
expect(updateScale).toBeDefined();
});
it('should return a new copy of the scale', () => {
const scale = scaleLinear();
const nextScale = updateScale(scale);
expect(scale).not.toBe(nextScale);
});
it('linear', () => {
const scale = updateScale(scaleLinear(), { domain: [0, 10], range: [2, 4] });
expect(scale(5)).toBe(3);
});
it('log', () => {
const scale = updateScale(scaleLog(), {
base: 2,
domain: [2, 8],
range: [1, 3],
});
expect(scale(4)?.toFixed(2)).toBe('2.00');
});
it('pow', () => {
const scale = updateScale(scalePower(), { exponent: 2, domain: [1, 3], range: [2, 18] });
expect(scale(2)).toBe(8);
});
it('sqrt', () => {
const scale = updateScale(scaleSqrt(), { domain: [1, 9], range: [1, 3] });
expect(scale(4)).toBe(2);
});
it('symlog', () => {
const scale = updateScale(scaleSymlog(), { domain: [1, 9], range: [1, 3], constant: 2 });
expect(scale(4)?.toFixed(2)).toBe('2.07');
});
it('time', () => {
TimezoneMock.register('US/Pacific');
const scale = updateScale(scaleTime(), {
domain: [new Date(2020, 0, 1), new Date(2020, 0, 10)],
range: [1, 10],
});
expect(scale(new Date(2020, 0, 4))).toBe(4);
TimezoneMock.unregister();
});
it('utc', () => {
const scale = updateScale(scaleUtc(), {
domain: [new Date(Date.UTC(2020, 0, 1)), new Date(Date.UTC(2020, 0, 10))],
range: [1, 10],
});
expect(scale(new Date(Date.UTC(2020, 0, 4)))).toBe(4);
});
it('quantile', () => {
const scale = updateScale(scaleQuantile(), { domain: [1, 3, 5, 7], range: [0, 10] });
expect(scale(2)).toBe(0);
});
it('quantize', () => {
const scale = updateScale(scaleQuantize(), { domain: [1, 10], range: ['red', 'green'] });
expect(scale(2)).toBe('red');
expect(scale(6)).toBe('green');
});
it('threshold', () => {
const scale = updateScale(scaleThreshold(), {
domain: [0, 1] as number[],
range: ['red', 'white', 'green'],
});
expect(scale(-1)).toBe('red');
expect(scale(0)).toBe('white');
expect(scale(0.5)).toBe('white');
expect(scale(1)).toBe('green');
expect(scale(1000)).toBe('green');
});
it('ordinal', () => {
const scale = updateScale<string | undefined, 'pig' | 'cat'>(
scaleOrdinal<'pig' | 'cat', string | undefined>(),
{
domain: ['pig', 'cat'],
range: ['red', 'green'],
},
);
expect(scale('pig')).toBe('red');
expect(scale('cat')).toBe('green');
});
it('point', () => {
const scale = updateScale(scalePoint(), {
domain: ['a', 'b', 'c'],
range: [1.1, 3.5],
round: true,
});
expect(scale('a')).toBe(1);
expect(scale('b')).toBe(2);
expect(scale('c')).toBe(3);
});
it('band', () => {
const scale = updateScale(scaleBand(), {
domain: ['a', 'b', 'c'],
range: [1.1, 3.5],
round: false,
});
expect(scale('a')).toBe(1.1);
expect(scale('b')).toBe(1.9);
expect(scale('c')).toBe(2.7);
});
it('invalid type', () => {
// @ts-expect-error
expect(updateScale(scaleLinear(), { type: 'invalid' })).toBeDefined();
});
});
|
8,002 | 0 | petrpan-code/airbnb/visx/packages/visx-scale/test | petrpan-code/airbnb/visx/packages/visx-scale/test/utils/coerceNumber.test.ts | import coerceNumber from '../../src/utils/coerceNumber';
describe('coerceNumber(mayBeNumberLike)', () => {
it('coerces NumberLike to number', () => {
expect(coerceNumber({ valueOf: () => 1 })).toBe(1);
expect(coerceNumber(new Date(10))).toBe(10);
});
it('returns the same thing if not', () => {
expect(coerceNumber('x')).toBe('x');
expect(coerceNumber(2)).toBe(2);
expect(coerceNumber(0)).toBe(0);
expect(coerceNumber(null)).toBeNull();
expect(coerceNumber(undefined)).toBeUndefined();
expect(coerceNumber({ x: 1 })).toEqual({ x: 1 });
});
});
|
8,003 | 0 | petrpan-code/airbnb/visx/packages/visx-scale/test | petrpan-code/airbnb/visx/packages/visx-scale/test/utils/getTicks.test.ts | import getTicks from '../../src/utils/getTicks';
import { scaleLinear, scaleBand } from '../../src';
describe('getTicks(scale)', () => {
it('linear', () => {
const scale = scaleLinear();
expect(getTicks(scale, 3)).toEqual([0, 0.5, 1]);
expect(getTicks(scale, 2)).toEqual([0, 0.5, 1]);
expect(getTicks(scale, 1)).toEqual([0, 1]);
});
it('band', () => {
const scale = scaleBand({
domain: ['a', 'b', 'c', 'd'],
});
expect(getTicks(scale, 4)).toEqual(['a', 'b', 'c', 'd']);
expect(getTicks(scale, 3)).toEqual(['a', 'b', 'c', 'd']);
expect(getTicks(scale, 2)).toEqual(['a', 'c']);
});
});
|
8,004 | 0 | petrpan-code/airbnb/visx/packages/visx-scale/test | petrpan-code/airbnb/visx/packages/visx-scale/test/utils/inferScaleType.test.ts | import {
scaleLinear,
scaleLog,
scalePow,
scaleSqrt,
scaleSymlog,
scaleTime,
scaleUtc,
scaleQuantile,
scaleQuantize,
scaleThreshold,
scaleOrdinal,
scalePoint,
scaleBand,
} from '@visx/vendor/d3-scale';
import TimezoneMock from 'timezone-mock';
import inferScaleType from '../../src/utils/inferScaleType';
describe('inferScaleType(scale)', () => {
it('linear scale', () => {
expect(inferScaleType(scaleLinear())).toBe('linear');
});
it('log scale', () => {
expect(inferScaleType(scaleLog())).toBe('log');
});
it('pow scale', () => {
expect(inferScaleType(scalePow())).toBe('pow');
});
it('sqrt scale', () => {
expect(inferScaleType(scaleSqrt())).toBe('sqrt');
});
it('symlog scale', () => {
expect(inferScaleType(scaleSymlog())).toBe('symlog');
});
describe('time scale', () => {
it('returns time when local time is not UTC', () => {
TimezoneMock.register('US/Pacific');
expect(inferScaleType(scaleTime())).toBe('time');
TimezoneMock.unregister();
});
it('returns utc when local time is UTC', () => {
TimezoneMock.register('UTC');
expect(inferScaleType(scaleTime())).toBe('utc');
TimezoneMock.unregister();
});
});
it('utc scale', () => {
expect(inferScaleType(scaleUtc())).toBe('utc');
});
it('quantile scale', () => {
expect(inferScaleType(scaleQuantile())).toBe('quantile');
});
it('quantize scale', () => {
expect(inferScaleType(scaleQuantize())).toBe('quantize');
});
it('threshold scale', () => {
expect(inferScaleType(scaleThreshold())).toBe('threshold');
});
it('ordinal scale', () => {
expect(inferScaleType(scaleOrdinal<string>())).toBe('ordinal');
});
it('point scale', () => {
expect(inferScaleType(scalePoint())).toBe('point');
});
it('band scale', () => {
expect(inferScaleType(scaleBand())).toBe('band');
});
});
|
8,005 | 0 | petrpan-code/airbnb/visx/packages/visx-scale/test | petrpan-code/airbnb/visx/packages/visx-scale/test/utils/isUtcScale.test.ts | import { scaleUtc, scaleTime } from '@visx/vendor/d3-scale';
import TimezoneMock from 'timezone-mock';
import isUtcScale from '../../src/utils/isUtcScale';
describe('isUtcScale(scale)', () => {
it('returns true for utc scale', () => {
expect(isUtcScale(scaleUtc())).toBe(true);
});
describe('for time scale', () => {
it('returns false when local time is not UTC', () => {
TimezoneMock.register('US/Pacific');
expect(isUtcScale(scaleTime())).toBe(false);
TimezoneMock.unregister();
});
it('returns true when local time is UTC', () => {
TimezoneMock.register('UTC');
expect(isUtcScale(scaleTime())).toBe(true);
TimezoneMock.unregister();
});
});
});
|
8,006 | 0 | petrpan-code/airbnb/visx/packages/visx-scale/test | petrpan-code/airbnb/visx/packages/visx-scale/test/utils/scaleCanBeZeroed.test.ts | import scaleCanBeZeroed from '../../src/utils/scaleCanBeZeroed';
describe('scaleCanBeZeroed(scaleConfig)', () => {
it('returns true for zero-able scales', () => {
const zeroAble = ['linear', 'pow', 'quantize', 'sqrt', 'symlog'] as const;
expect.assertions(zeroAble.length);
zeroAble.forEach((type) => expect(scaleCanBeZeroed({ type })).toBe(true));
});
it('returns false for non-zero-able scales', () => {
const notZeroAble = [
'log',
'radial',
'time',
'utc',
'quantile',
'threshold',
'ordinal',
'point',
'band',
] as const;
expect.assertions(notZeroAble.length);
notZeroAble.forEach((type) => expect(scaleCanBeZeroed({ type })).toBe(false));
});
});
|
8,007 | 0 | petrpan-code/airbnb/visx/packages/visx-scale/test | petrpan-code/airbnb/visx/packages/visx-scale/test/utils/toString.test.ts | import toString from '../../src/utils/toString';
describe('toString(mayBeStringLike)', () => {
it('converts StringLike to string', () => {
expect(toString({ toString: () => 'haha' })).toBe('haha');
expect(toString('x')).toBe('x');
expect(toString(2)).toBe('2');
expect(toString(0)).toBe('0');
expect(toString({ x: 1 })).toBe('[object Object]');
});
it('returns the same thing if not', () => {
expect(toString(undefined)).toBeUndefined();
});
});
|
8,061 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/Arc.test.tsx | import React from 'react';
import mockConsole from 'jest-mock-console';
import { render } from '@testing-library/react';
import { Arc } from '../src';
import { ArcProps } from '../src/shapes/Arc';
import '@testing-library/jest-dom';
interface Datum {
data: number;
value: number;
index: number;
startAngle: number;
endAngle: number;
padAngle: number;
}
const data: Datum = {
data: 1,
value: 1,
index: 6,
startAngle: 6.050474740247008,
endAngle: 6.166830023713296,
padAngle: 0,
};
const ArcChildren = ({ children, ...restProps }: Partial<ArcProps<Datum>>) =>
render(
<Arc data={data} {...restProps}>
{children}
</Arc>,
);
describe('<Arc />', () => {
it('should be defined', () => {
expect(Arc).toBeDefined();
});
it('should render a path that has the .visx-arcs-group class', () => {
const { container } = render(
<svg>
<Arc data={data} />
</svg>,
);
const PathElement = container.querySelector('path');
expect(PathElement).toBeInTheDocument();
expect(PathElement).toHaveClass('visx-arc');
});
it('should warn and render null when none of data, radii, and angles are passed', () => {
const restoreConsole = mockConsole();
const { container } = render(
<svg>
<Arc data={null} />
</svg>,
);
expect(container.querySelector('path')).not.toBeInTheDocument();
expect(console.warn).toHaveBeenCalledTimes(1);
restoreConsole();
});
it('should render a path without data when radii + angles are defined', () => {
const { container } = render(
<svg>
<Arc data={{ startAngle: 0, endAngle: 6, innerRadius: 5, outerRadius: 10 }} />
</svg>,
);
expect(container.querySelector('path')).toBeInTheDocument();
});
it('should take a children as function prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn });
expect(fn).toHaveBeenCalled();
});
it('should call children function with { path }', () => {
const fn = jest.fn();
ArcChildren({ children: fn });
const args = fn.mock.calls[0][0];
const keys = Object.keys(args);
expect(keys).toContain('path');
});
it('should take an innerRadius number prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, innerRadius: 42 });
const args = fn.mock.calls[0][0];
expect(args.path.innerRadius()()).toBe(42);
});
it('should take an innerRadius fn prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, innerRadius: () => 42 });
const args = fn.mock.calls[0][0];
expect(args.path.innerRadius()()).toBe(42);
});
it('should take an outerRadius number prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, outerRadius: 42 });
const args = fn.mock.calls[0][0];
expect(args.path.outerRadius()()).toBe(42);
});
it('should take an outerRadius fn prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, outerRadius: () => 42 });
const args = fn.mock.calls[0][0];
expect(args.path.outerRadius()()).toBe(42);
});
it('should take a cornerRadius number prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, cornerRadius: 42 });
const args = fn.mock.calls[0][0];
expect(args.path.cornerRadius()()).toBe(42);
});
it('should take a cornerRadius fn prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, cornerRadius: () => 42 });
const args = fn.mock.calls[0][0];
expect(args.path.cornerRadius()()).toBe(42);
});
it('should take a startAngle number prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, startAngle: 42 });
const args = fn.mock.calls[0][0];
expect(args.path.startAngle()()).toBe(42);
});
it('should take a startAngle 0 prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, startAngle: 0 });
const args = fn.mock.calls[0][0];
expect(args.path.startAngle()()).toBe(0);
});
it('should take a startAngle fn prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, startAngle: () => 42 });
const args = fn.mock.calls[0][0];
expect(args.path.startAngle()()).toBe(42);
});
it('should take a endAngle number prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, endAngle: 42 });
const args = fn.mock.calls[0][0];
expect(args.path.endAngle()()).toBe(42);
});
it('should take a endAngle 0 prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, endAngle: 0 });
const args = fn.mock.calls[0][0];
expect(args.path.endAngle()()).toBe(0);
});
it('should take a endAngle fn prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, endAngle: () => 42 });
const args = fn.mock.calls[0][0];
expect(args.path.endAngle()()).toBe(42);
});
it('should take a padAngle number prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, padAngle: 42 });
const args = fn.mock.calls[0][0];
expect(args.path.padAngle()()).toBe(42);
});
it('should take a padAngle 0 prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, padAngle: 0 });
const args = fn.mock.calls[0][0];
expect(args.path.padAngle()()).toBe(0);
});
it('should take a padAngle fn prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, padAngle: () => 42 });
const args = fn.mock.calls[0][0];
expect(args.path.padAngle()()).toBe(42);
});
it('should take a padRadius number prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, padRadius: 42 });
const args = fn.mock.calls[0][0];
expect(args.path.padRadius()()).toBe(42);
});
it('should take a padRadius 0 prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, padRadius: 0 });
const args = fn.mock.calls[0][0];
expect(args.path.padRadius()()).toBe(0);
});
it('should take a padRadius fn prop', () => {
const fn = jest.fn();
ArcChildren({ children: fn, padRadius: () => 42 });
const args = fn.mock.calls[0][0];
expect(args.path.padRadius()()).toBe(42);
});
it('calling path with data returns a string', () => {
const fn = jest.fn();
ArcChildren({ children: fn });
const args = fn.mock.calls[0][0];
expect(typeof args.path(data)).toBe('string');
});
it('should expose its ref via an innerRef prop', () => {
const fakeRef = React.createRef<SVGPathElement>();
const { container } = render(
<svg>
<Arc data={data} innerRef={fakeRef} />
</svg>,
);
const PathElement = container.querySelector('path');
expect(fakeRef.current).toContainElement(PathElement);
});
});
|
8,062 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/Area.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { render } from '@testing-library/react';
import '@testing-library/jest-dom';
import { Area } from '../src';
import { AreaProps } from '../src/shapes/Area';
interface Datum {
x: Date;
y: number;
}
const fakeData: Datum[] = [
{ x: new Date('2017-01-01'), y: 5 },
{ x: new Date('2017-01-02'), y: 5 },
{ x: new Date('2017-01-03'), y: 5 },
];
const AreaChildren = ({ children, ...restProps }: Partial<AreaProps<Datum>>) =>
shallow(
<Area data={fakeData} {...restProps}>
{children}
</Area>,
);
const xScale = () => 50;
const yScale = () => 50;
yScale.range = () => [100, 0];
const x = () => xScale();
const y = () => yScale();
describe('<Area />', () => {
test('it should be defined', () => {
expect(Area).toBeDefined();
});
test('it should have the .visx-area class', () => {
const wrapper = shallow(<Area data={fakeData} x={x} y={y} />);
expect(wrapper.find('path').prop('className')).toBe('visx-area');
});
test('it should expose its ref via an innerRef prop', () => {
const fakeRef = React.createRef<SVGPathElement>();
const { container } = render(
<svg>
<Area data={fakeData} x={x} y={y} innerRef={fakeRef} />
</svg>,
);
const PathElement = container.querySelector('path');
expect(fakeRef.current).toContainElement(PathElement);
});
test('it should take a children as function prop', () => {
const fn = jest.fn();
AreaChildren({ children: fn });
expect(fn).toHaveBeenCalled();
});
test('it should call children function with { path }', () => {
const fn = jest.fn();
AreaChildren({ children: fn });
const args = fn.mock.calls[0][0];
const keys = Object.keys(args);
expect(keys).toContain('path');
});
test('it should take an x number prop', () => {
const fn = jest.fn();
AreaChildren({ children: fn, x: 42 });
const args = fn.mock.calls[0][0];
expect(args.path.x()()).toBe(42);
});
test('it should take an x fn prop', () => {
const fn = jest.fn();
AreaChildren({ children: fn, x: () => 42 });
const args = fn.mock.calls[0][0];
expect(args.path.x()()).toBe(42);
expect(args.path.x0()()).toBe(42);
expect(args.path.x1()).toBeNull();
});
test('it should take an y number prop', () => {
const fn = jest.fn();
AreaChildren({ children: fn, y: 42 });
const args = fn.mock.calls[0][0];
expect(args.path.y()()).toBe(42);
});
test('it should take an y fn prop', () => {
const fn = jest.fn();
AreaChildren({ children: fn, y: () => 42 });
const args = fn.mock.calls[0][0];
expect(args.path.y()()).toBe(42);
expect(args.path.y0()()).toBe(42);
expect(args.path.y1()).toBeNull();
});
test('it should default defined prop to true', () => {
const fn = jest.fn();
AreaChildren({ children: fn });
const args = fn.mock.calls[0][0];
expect(args.path.defined()()).toBe(true);
});
test('calling path with data returns a string', () => {
const fn = jest.fn();
AreaChildren({ children: fn });
const args = fn.mock.calls[0][0];
expect(typeof args.path(fakeData)).toBe('string');
});
});
|
8,063 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/AreaClosed.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { render } from '@testing-library/react';
import '@testing-library/jest-dom';
import { scaleLinear } from '@visx/scale';
import { AreaClosed } from '../src';
import { AreaClosedProps } from '../src/shapes/AreaClosed';
interface Datum {
x: Date;
y: number;
}
const data: Datum[] = [
{ x: new Date('2017-01-01'), y: 5 },
{ x: new Date('2017-01-02'), y: 5 },
{ x: new Date('2017-01-03'), y: 5 },
];
const yScale = scaleLinear({ domain: [0, 100], range: [100, 0] });
const x = () => 50;
const y = () => 50;
const AreaClosedWrapper = (restProps = {}) =>
shallow(<AreaClosed data={data} yScale={yScale} x={x} y1={y} {...restProps} />);
const AreaClosedChildren = ({ children, ...restProps }: Partial<AreaClosedProps<Datum>>) =>
shallow(
<AreaClosed data={data} yScale={yScale} x={x} y1={y} {...restProps}>
{children}
</AreaClosed>,
);
describe('<AreaClosed />', () => {
test('it should be defined', () => {
expect(AreaClosed).toBeDefined();
});
test('it should have the .visx-area-closed class', () => {
expect(AreaClosedWrapper().prop('className')).toBe('visx-area-closed');
});
test('it should expose its ref via an innerRef prop', () => {
const fakeRef = React.createRef<SVGPathElement>();
const { container } = render(
<svg>
<AreaClosed data={data} yScale={yScale} x={x} y1={y} innerRef={fakeRef} />
</svg>,
);
const PathElement = container.querySelector('path');
expect(fakeRef.current).toContainElement(PathElement);
});
test('it should take a children as function prop', () => {
const fn = jest.fn();
AreaClosedChildren({ children: fn });
expect(fn).toHaveBeenCalled();
});
test('it should call children function with { path }', () => {
const fn = jest.fn();
AreaClosedChildren({ children: fn });
const args = fn.mock.calls[0][0];
const keys = Object.keys(args);
expect(keys).toContain('path');
});
test('it should take an x number prop', () => {
const fn = jest.fn();
AreaClosedChildren({ children: fn, x: 42 });
const args = fn.mock.calls[0][0];
expect(args.path.x()()).toBe(42);
});
test('it should take an x fn prop', () => {
const fn = jest.fn();
AreaClosedChildren({ children: fn, x: () => 42 });
const args = fn.mock.calls[0][0];
expect(args.path.x()()).toBe(42);
expect(args.path.x0()()).toBe(42);
expect(args.path.x1()).toBeNull();
});
test('it should take an y number prop', () => {
const fn = jest.fn();
AreaClosedChildren({ children: fn, y1: 42 });
const args = fn.mock.calls[0][0];
expect(args.path.y0()()).toBe(yScale.range()[0]);
expect(args.path.y1()()).toBe(42);
});
test('it should take an y fn prop', () => {
const fn = jest.fn();
AreaClosedChildren({ children: fn, y1: () => 42 });
const args = fn.mock.calls[0][0];
expect(args.path.y()()).toBe(yScale.range()[0]);
expect(args.path.y0()()).toBe(yScale.range()[0]);
expect(args.path.y1()()).toBe(42);
});
test('it should default defined prop to true', () => {
const fn = jest.fn();
AreaClosedChildren({ children: fn });
const args = fn.mock.calls[0][0];
expect(args.path.defined()()).toBe(true);
});
test('calling path with data returns a string', () => {
const fn = jest.fn();
AreaClosedChildren({ children: fn });
const args = fn.mock.calls[0][0];
expect(typeof args.path(data)).toBe('string');
});
});
|
8,064 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/AreaStack.test.tsx | import { AreaStack } from '../src';
describe('<AreaStack />', () => {
test('it should be defined', () => {
expect(AreaStack).toBeDefined();
});
});
|
8,065 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/Bar.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { render } from '@testing-library/react';
import '@testing-library/jest-dom';
import { Bar } from '../src';
const BarWrapper = (restProps = {}) => shallow(<Bar {...restProps} />);
describe('<Bar />', () => {
test('it should be defined', () => {
expect(Bar).toBeDefined();
});
test('it should have the .visx-bar class', () => {
expect(
BarWrapper({
className: 'test',
}).prop('className'),
).toBe('visx-bar test');
});
test('it should expose its ref via an innerRef prop', () => {
const fakeRef = React.createRef<SVGRectElement>();
const { container } = render(
<svg>
<Bar innerRef={fakeRef} />
</svg>,
);
const RectElement = container.querySelector('rect');
expect(fakeRef.current).toContainElement(RectElement);
});
});
|
8,066 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/BarGroup.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { scaleBand, scaleLinear } from '@visx/scale';
import { BarGroup } from '../src';
import { BarGroupProps } from '../src/shapes/BarGroup';
import { GroupKey } from '../src/types/barGroup';
interface Datum {
date: Date;
'New York': string;
'San Francisco': string;
Austin: string;
}
const data: Datum[] = [
{
date: new Date(),
'New York': '63.4',
'San Francisco': '62.7',
Austin: '72.2',
},
{
date: new Date(),
'New York': '58.0',
'San Francisco': '59.9',
Austin: '67.7',
},
];
const x0 = () => 5;
const x0Scale = scaleBand({ domain: [5, 15], range: [0, 100] });
const x1Scale = scaleBand({ domain: [0, 100], range: [0, 100] });
const yScale = scaleLinear({ domain: [0, 100], range: [0, 100] });
const color = () => 'skyblue';
const keys = ['New York', 'San Francisco', 'Austin'];
const height = 1;
const BarGroupWrapper = (restProps = {}) =>
shallow(
<BarGroup
data={data}
x0={x0}
x0Scale={x0Scale}
x1Scale={x1Scale}
yScale={yScale}
color={color}
keys={keys}
height={height}
{...restProps}
/>,
);
const BarGroupChildren = ({ children, ...restProps }: Partial<BarGroupProps<Datum, GroupKey>>) =>
shallow(
<BarGroup
data={data}
x0={x0}
x0Scale={x0Scale}
x1Scale={x1Scale}
yScale={yScale}
color={color}
keys={keys}
height={height}
{...restProps}
>
{children}
</BarGroup>,
);
describe('<BarGroup />', () => {
test('it should be defined', () => {
expect(BarGroup).toBeDefined();
});
test('it should have className .visx-bar-group', () => {
const wrapper = BarGroupWrapper();
expect(wrapper.prop('className')).toBe('visx-bar-group');
});
test('it should set className prop', () => {
const wrapper = BarGroupWrapper({ className: 'test' });
expect(wrapper.prop('className')).toBe('visx-bar-group test');
});
test('it should set top & left props', () => {
const wrapper = BarGroupWrapper({ top: 2, left: 3 });
expect(wrapper.prop('top')).toBe(2);
expect(wrapper.prop('left')).toBe(3);
});
test('it should take a children as function prop', () => {
const fn = jest.fn();
BarGroupChildren({ children: fn });
expect(fn).toHaveBeenCalled();
});
test('it should call children function with [barGroups]', () => {
const fn = jest.fn();
BarGroupChildren({ children: fn });
const args = fn.mock.calls[0][0];
expect(args.length > 0).toBe(true);
});
test('it should create barGroup with shape { index, x0, bars }', () => {
const fn = jest.fn();
BarGroupChildren({ children: fn });
const args = fn.mock.calls[0][0];
const barGroups = args;
const group = barGroups[0];
expect(Object.keys(group)).toEqual(['index', 'x0', 'bars']);
expect(group.index).toBe(0);
expect(typeof group.index).toBe('number');
expect(typeof group.x0).toBe('number');
expect(group.bars).toHaveLength(keys.length);
expect(Object.keys(group.bars[0])).toEqual([
'index',
'key',
'value',
'width',
'x',
'y',
'color',
'height',
]);
});
});
|
8,067 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/BarGroupHorizontal.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { scaleBand, scaleLinear } from '@visx/scale';
import { BarGroupHorizontal } from '../src';
import { BarGroupHorizontalProps } from '../lib/shapes/BarGroupHorizontal';
interface Datum {
date: Date;
'New York': string;
'San Francisco': string;
Austin: string;
}
const data: Datum[] = [
{
date: new Date(),
'New York': '63.4',
'San Francisco': '62.7',
Austin: '72.2',
},
{
date: new Date(),
'New York': '58.0',
'San Francisco': '59.9',
Austin: '67.7',
},
];
const y0 = () => 5;
const y0Scale = scaleBand({ domain: [0, 100], range: [0, 100] });
const y1Scale = scaleBand({ domain: [0, 100], range: [0, 100] });
const xScale = scaleLinear({ domain: [0, 100], range: [0, 100] });
const color = () => 'violet';
const keys = ['New York', 'San Francisco', 'Austin'];
const width = 1;
const BarGroupWrapper = (restProps = {}) =>
shallow(
<BarGroupHorizontal
data={data}
y0={y0}
y0Scale={y0Scale}
y1Scale={y1Scale}
xScale={xScale}
color={color}
keys={keys}
width={width}
{...restProps}
/>,
);
const BarGroupChildren = ({ children, ...restProps }: Partial<BarGroupHorizontalProps<Datum>>) =>
shallow(
<BarGroupHorizontal
data={data}
y0={y0}
y0Scale={y0Scale}
y1Scale={y1Scale}
xScale={xScale}
color={color}
keys={keys}
width={width}
{...restProps}
>
{children}
</BarGroupHorizontal>,
);
describe('<BarGroupHorizontal />', () => {
test('it should be defined', () => {
expect(BarGroupHorizontal).toBeDefined();
});
test('it should have className .visx-bar-group', () => {
const wrapper = BarGroupWrapper();
expect(wrapper.prop('className')).toBe('visx-bar-group-horizontal');
});
test('it should set className prop', () => {
const wrapper = BarGroupWrapper({ className: 'test' });
expect(wrapper.prop('className')).toBe('visx-bar-group-horizontal test');
});
test('it should set top & left props', () => {
const wrapper = BarGroupWrapper({ top: 2, left: 3 });
expect(wrapper.prop('top')).toBe(2);
expect(wrapper.prop('left')).toBe(3);
});
test('it should take a children as function prop', () => {
const fn = jest.fn();
BarGroupChildren({ children: fn });
expect(fn).toHaveBeenCalled();
});
test('it should call children function with [barGroups]', () => {
const fn = jest.fn();
BarGroupChildren({ children: fn });
const args = fn.mock.calls[0][0];
expect(args.length > 0).toBe(true);
});
test('it should create barGroup with shape { index, x0, bars }', () => {
const fn = jest.fn();
BarGroupChildren({ children: fn });
const args = fn.mock.calls[0][0];
const barGroups = args;
const group = barGroups[0];
expect(Object.keys(group)).toEqual(['index', 'y0', 'bars']);
expect(group.index).toBe(0);
expect(typeof group.index).toBe('number');
expect(typeof group.y0).toBe('number');
expect(group.bars).toHaveLength(keys.length);
expect(Object.keys(group.bars[0])).toEqual([
'index',
'key',
'value',
'height',
'x',
'y',
'color',
'width',
]);
});
});
|
8,068 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/BarRounded.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { render } from '@testing-library/react';
import '@testing-library/jest-dom';
import { BarRounded } from '../src';
import { useBarRoundedPath } from '../src/shapes/BarRounded';
const testProps = { x: 0, y: 0, width: 10, height: 20, radius: 2 };
const BarRoundedWrapper = (restProps = {}) => shallow(<BarRounded {...testProps} {...restProps} />);
describe('<BarRounded />', () => {
it('should be defined', () => {
expect(BarRounded).toBeDefined();
});
it('should have the .visx-bar-rounded class', () => {
expect(
BarRoundedWrapper({
className: 'test',
}).prop('className'),
).toBe('visx-bar-rounded test');
});
it('should expose its ref via an innerRef prop', () => {
const fakeRef = React.createRef<SVGPathElement>();
const { container } = render(
<svg>
<BarRounded innerRef={fakeRef} {...testProps} />
</svg>,
);
const PathElement = container.querySelector('path');
expect(fakeRef.current).toContainElement(PathElement);
});
it('should support hooks with useBarRoundedPath', () => {
const path = useBarRoundedPath({ ...testProps, all: true });
expect(path).toBe(
'M2,0 h6 a2,2 0 0 1 2,2 v16 a2,2 0 0 1 -2,2 h-6 a2,2 0 0 1 -2,-2 v-16 a2,2 0 0 1 2,-2z',
);
});
it('should set top left corner radius', () => {
const wrapper = BarRoundedWrapper({ topLeft: true });
expect(wrapper.prop('d')).toBe('M2,0 h6 h2v2 v16 v2h-2 h-6 h-2v-2 v-16 a2,2 0 0 1 2,-2z');
});
it('should set top right corner radius', () => {
const wrapper = BarRoundedWrapper({ topRight: true });
expect(wrapper.prop('d')).toBe('M2,0 h6 a2,2 0 0 1 2,2 v16 v2h-2 h-6 h-2v-2 v-16 v-2h2z');
});
it('should set bottom left corner radius', () => {
const wrapper = BarRoundedWrapper({ bottomLeft: true });
expect(wrapper.prop('d')).toBe('M2,0 h6 h2v2 v16 v2h-2 h-6 a2,2 0 0 1 -2,-2 v-16 v-2h2z');
});
it('should set bottom right corner radius', () => {
const wrapper = BarRoundedWrapper({ bottomRight: true });
expect(wrapper.prop('d')).toBe('M2,0 h6 h2v2 v16 a2,2 0 0 1 -2,2 h-6 h-2v-2 v-16 v-2h2z');
});
it('should set top left & top right corner radius', () => {
const wrapper = BarRoundedWrapper({ top: true });
expect(wrapper.prop('d')).toBe(
'M2,0 h6 a2,2 0 0 1 2,2 v16 v2h-2 h-6 h-2v-2 v-16 a2,2 0 0 1 2,-2z',
);
});
it('should set bottom left & bottom right corner radius', () => {
const wrapper = BarRoundedWrapper({ bottom: true });
expect(wrapper.prop('d')).toBe(
'M2,0 h6 h2v2 v16 a2,2 0 0 1 -2,2 h-6 a2,2 0 0 1 -2,-2 v-16 v-2h2z',
);
});
it('should set top left & bottom left corner radius', () => {
const wrapper = BarRoundedWrapper({ left: true });
expect(wrapper.prop('d')).toBe(
'M2,0 h6 h2v2 v16 v2h-2 h-6 a2,2 0 0 1 -2,-2 v-16 a2,2 0 0 1 2,-2z',
);
});
it('should set top right & bottom right corner radius', () => {
const wrapper = BarRoundedWrapper({ right: true });
expect(wrapper.prop('d')).toBe(
'M2,0 h6 a2,2 0 0 1 2,2 v16 a2,2 0 0 1 -2,2 h-6 h-2v-2 v-16 v-2h2z',
);
});
it('should set all corner radius', () => {
const wrapper = BarRoundedWrapper({ all: true });
expect(wrapper.prop('d')).toBe(
'M2,0 h6 a2,2 0 0 1 2,2 v16 a2,2 0 0 1 -2,2 h-6 a2,2 0 0 1 -2,-2 v-16 a2,2 0 0 1 2,-2z',
);
});
it('should clamp radius to the center of the shortest side of the rect', () => {
const wrapper = BarRoundedWrapper({ topLeft: true, width: 4, radius: 400 });
const r = Math.min(4, testProps.height) / 2;
expect(wrapper.prop('d')).toBe(
`M2,0 h0 h2v2 v16 v2h-2 h0 h-2v-2 v-16 a${r},${r} 0 0 1 ${r},-${r}z`,
);
});
});
|
8,069 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/BarStack.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { scaleBand } from '@visx/scale';
import { BarStack } from '../src';
const scale = scaleBand({
domain: [0, 100],
range: [0, 100],
});
describe('<BarStack />', () => {
test('it should be defined', () => {
expect(BarStack).toBeDefined();
});
test('it should have className .visx-bar-stack', () => {
const wrapper = shallow(
<BarStack
data={[]}
top={2}
left={3}
x={(d) => d}
xScale={scale}
yScale={scale}
color={(d) => d}
keys={[]}
/>,
);
expect(wrapper.prop('className')).toBe('visx-bar-stack');
});
test('it should set className prop', () => {
const wrapper = shallow(
<BarStack
className="test"
data={[]}
top={2}
left={3}
x={(d) => d}
xScale={scale}
yScale={scale}
color={(d) => d}
keys={[]}
/>,
);
expect(wrapper.prop('className')).toBe('visx-bar-stack test');
});
test('it should set top & left props', () => {
const wrapper = shallow(
<BarStack
className="test"
data={[]}
top={2}
left={3}
x={(d) => d}
xScale={scale}
yScale={scale}
color={(d) => d}
keys={[]}
/>,
);
expect(wrapper.prop('top')).toBe(2);
expect(wrapper.prop('left')).toBe(3);
});
});
|
8,070 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/BarStackHorizontal.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { scaleBand } from '@visx/scale';
import { BarStackHorizontal } from '../src';
const scale = scaleBand({
domain: [0, 100],
range: [0, 100],
paddingInner: 5,
paddingOuter: 5,
});
describe('<BarStackHorizontal />', () => {
test('it should be defined', () => {
expect(BarStackHorizontal).toBeDefined();
});
test('it should have className .visx-bar-stack-horizontal', () => {
const wrapper = shallow(
<BarStackHorizontal
data={[]}
top={2}
left={3}
y={(d) => d}
xScale={scale}
yScale={scale}
color={(d) => d}
keys={[]}
/>,
);
expect(wrapper.prop('className')).toBe('visx-bar-stack-horizontal');
});
test('it should set className prop', () => {
const wrapper = shallow(
<BarStackHorizontal
className="test"
data={[]}
top={2}
left={3}
y={(d) => d}
xScale={scale}
yScale={scale}
color={(d) => d}
keys={[]}
/>,
);
expect(wrapper.prop('className')).toBe('visx-bar-stack-horizontal test');
});
test('it should set top & left props', () => {
const wrapper = shallow(
<BarStackHorizontal
className="test"
data={[]}
top={2}
left={3}
y={(d) => d}
xScale={scale}
yScale={scale}
color={(d) => d}
keys={[]}
/>,
);
expect(wrapper.prop('top')).toBe(2);
expect(wrapper.prop('left')).toBe(3);
});
});
|
8,071 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/Circle.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { render } from '@testing-library/react';
import '@testing-library/jest-dom';
import { Circle } from '../src';
const CircleWrapper = ({ ...restProps }) => shallow(<Circle {...restProps} />);
describe('<Circle />', () => {
test('it should be defined', () => {
expect(Circle).toBeDefined();
});
test('it should have the .visx-circle class', () => {
expect(
CircleWrapper({
className: 'test',
}).prop('className'),
).toBe('visx-circle test');
});
test('it should expose its ref via an innerRef prop', () => {
const fakeRef = React.createRef<SVGCircleElement>();
const { container } = render(
<svg>
<Circle innerRef={fakeRef} />
</svg>,
);
const CircleElement = container.querySelector('circle');
expect(fakeRef.current).toContainElement(CircleElement);
});
});
|
8,072 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/Line.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { render } from '@testing-library/react';
import '@testing-library/jest-dom';
import { Line } from '../src';
const LineWrapper = (restProps = {}) => shallow(<Line {...restProps} />);
describe('<Line />', () => {
test('it should be defined', () => {
expect(Line).toBeDefined();
});
test('it should contain a <line />', () => {
expect(LineWrapper().find('line')).toHaveLength(1);
});
test('it should have the .visx-line class', () => {
expect(LineWrapper().prop('className')).toBe('visx-line');
});
test('it should expose its ref via an innerRef prop', () => {
const fakeRef = React.createRef<SVGLineElement>();
const { container } = render(
<svg>
<Line innerRef={fakeRef} />
</svg>,
);
const LineElement = container.querySelector('line');
expect(fakeRef.current).toContainElement(LineElement);
});
test('it should set shapeRendering to auto if not rectilinear', () => {
expect(
LineWrapper({
to: {
x: 50,
y: 100,
},
}).prop('shapeRendering'),
).toBe('auto');
});
test('it should set shapeRendering to crispEdges if rectilinear', () => {
expect(
LineWrapper({
to: {
x: 0,
y: 100,
},
}).prop('shapeRendering'),
).toBe('crispEdges');
expect(
LineWrapper({
to: {
x: 100,
y: 0,
},
}).prop('shapeRendering'),
).toBe('crispEdges');
});
});
|
8,073 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/LinePath.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { render } from '@testing-library/react';
import '@testing-library/jest-dom';
import { LinePath } from '../src';
import { LinePathProps } from '../src/shapes/LinePath';
interface Datum {
x: number;
y: number;
}
const linePathProps = {
data: [
{ x: 0, y: 0 },
{ x: 1, y: 1 },
],
x: (d: Datum) => d.x,
y: (d: Datum) => d.y,
};
const LinePathWrapper = (restProps = {}) => shallow(<LinePath {...restProps} />);
const LinePathChildren = ({ children, ...restProps }: Partial<LinePathProps<Datum>>) =>
shallow(<LinePath {...restProps}>{children}</LinePath>);
describe('<LinePath />', () => {
it('should be defined', () => {
expect(LinePath).toBeDefined();
});
it('should have the .visx-linepath class', () => {
expect(LinePathWrapper(linePathProps).prop('className')).toBe('visx-linepath');
});
it('should default to strokeLinecap="round" for superior missing data rendering', () => {
expect(LinePathWrapper(linePathProps).prop('strokeLinecap')).toBe('round');
});
it('should contain paths', () => {
expect(LinePathWrapper(linePathProps).find('path').length).toBeGreaterThan(0);
});
it('should take a children as function prop', () => {
const fn = jest.fn();
LinePathChildren({ children: fn });
expect(fn).toHaveBeenCalled();
});
it('should call children function with { path }', () => {
const fn = jest.fn();
LinePathChildren({ children: fn });
const args = fn.mock.calls[0][0];
const keys = Object.keys(args);
expect(keys).toContain('path');
});
it('should expose its ref via an innerRef prop', () => {
const fakeRef = React.createRef<SVGPathElement>();
const { container } = render(
<svg>
<LinePath data={linePathProps.data} innerRef={fakeRef} />
</svg>,
);
const PathElement = container.querySelector('path');
expect(fakeRef.current).toContainElement(PathElement);
});
});
|
8,074 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/LineRadial.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { render } from '@testing-library/react';
import '@testing-library/jest-dom';
import { LineRadial } from '../src';
import { LineRadialProps } from '../src/shapes/LineRadial';
interface Datum {
x: number;
y: number;
}
const mockProps = {
data: [
{ x: 0, y: 0 },
{ x: 1, y: 1 },
],
angle: (d: Datum) => d.x,
radius: (d: Datum) => d.y,
};
const LineRadialWrapper = (restProps = {}) => shallow(<LineRadial {...restProps} />);
const LineRadialChildren = ({ children, ...restProps }: Partial<LineRadialProps<Datum>>) =>
shallow(<LineRadial {...restProps}>{children}</LineRadial>);
describe('<LineRadial />', () => {
test('it should be defined', () => {
expect(LineRadial).toBeDefined();
});
test('it should have the .visx-line-radial class', () => {
expect(LineRadialWrapper(mockProps).prop('className')).toBe('visx-line-radial');
});
test('it should contain paths', () => {
expect(LineRadialWrapper(mockProps).find('path').length).toBeGreaterThan(0);
});
test('it should take a children as function prop', () => {
const fn = jest.fn();
LineRadialChildren({ children: fn, ...mockProps });
expect(fn).toHaveBeenCalled();
});
test('it should call children function with { path }', () => {
const fn = jest.fn();
LineRadialChildren({ children: fn, ...mockProps });
const args = fn.mock.calls[0][0];
const keys = Object.keys(args);
expect(keys).toContain('path');
});
test('it should expose its ref via an innerRef prop', () => {
const fakeRef = React.createRef<SVGPathElement>();
const { container } = render(
<svg>
<LineRadial innerRef={fakeRef} {...mockProps} />
</svg>,
);
const PathElement = container.querySelector('path');
expect(fakeRef.current).toContainElement(PathElement);
});
});
|
8,075 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/LinkHorizontal.test.tsx | import React from 'react';
import { render } from '@testing-library/react';
import '@testing-library/jest-dom';
import { hierarchy } from 'd3-hierarchy';
import { LinkHorizontal } from '../src';
const mockHierarchy = hierarchy({
name: 'Eve',
children: [
{ name: 'Cain' },
{
name: 'Seth',
children: [{ name: 'Enos' }, { name: 'Noam' }],
},
],
});
const link = mockHierarchy.links()[0];
describe('<LinkHorizontal />', () => {
test('it should be defined', () => {
expect(LinkHorizontal).toBeDefined();
});
test('it should expose its ref via an innerRef prop', () => {
const fakeRef = React.createRef<SVGPathElement>();
const { container } = render(
<svg>
<LinkHorizontal innerRef={fakeRef} data={link} />
</svg>,
);
const PathElement = container.querySelector('path');
expect(fakeRef.current).toContainElement(PathElement);
});
});
|
8,076 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/LinkRadial.test.tsx | import { LinkRadial } from '../src';
describe('<LinkRadial />', () => {
test('it should be defined', () => {
expect(LinkRadial).toBeDefined();
});
});
|
8,077 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/LinkVertical.test.tsx | import React from 'react';
import { render } from '@testing-library/react';
import '@testing-library/jest-dom';
import { hierarchy } from 'd3-hierarchy';
import { LinkVertical } from '../src';
const mockHierarchy = hierarchy({
name: 'Eve',
children: [
{ name: 'Cain' },
{
name: 'Seth',
children: [{ name: 'Enos' }, { name: 'Noam' }],
},
],
});
const link = mockHierarchy.links()[0];
describe('<LinkVertical />', () => {
test('it should be defined', () => {
expect(LinkVertical).toBeDefined();
});
test('it should expose its ref via an innerRef prop', () => {
const fakeRef = React.createRef<SVGPathElement>();
const { container } = render(
<svg>
<LinkVertical data={link} innerRef={fakeRef} />
</svg>,
);
const PathElement = container.querySelector('path');
expect(fakeRef.current).toContainElement(PathElement);
});
});
|
8,078 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/Pie.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { Pie } from '../src';
import { PieArcDatum, PieProps } from '../src/shapes/Pie';
interface Datum {
date: string;
'Google Chrome': string;
'Internet Explorer': string;
Firefox: string;
Safari: string;
'Microsoft Edge': string;
Opera: string;
Mozilla: string;
'Other/Unknown': string;
color: string;
}
const browserUsage: Datum[] = [
{
date: '2015 Jun 15',
'Google Chrome': '48.09',
'Internet Explorer': '24.14',
Firefox: '18.82',
Safari: '7.46',
'Microsoft Edge': '0.03',
Opera: '1.32',
Mozilla: '0.12',
'Other/Unknown': '0.01',
color: 'blue',
},
{
date: '2015 Jun 16',
'Google Chrome': '48',
'Internet Explorer': '24.19',
Firefox: '18.96',
Safari: '7.36',
'Microsoft Edge': '0.03',
Opera: '1.32',
Mozilla: '0.12',
'Other/Unknown': '0.01',
color: 'red',
},
];
const PieWrapper = (restProps = {}) => shallow(<Pie data={browserUsage} {...restProps} />);
const PieChildren = ({ children, ...restProps }: Partial<PieProps<Datum>>) =>
shallow(
<Pie data={browserUsage} {...restProps}>
{children}
</Pie>,
);
describe('<Pie />', () => {
test('it should be defined', () => {
expect(Pie).toBeDefined();
});
test('it should not break on sort callbacks', () => {
expect(() => {
PieWrapper({ pieSort: () => 0, pieSortValues: () => 0 });
}).not.toThrow();
});
test('it should accept null sort callbacks', () => {
expect.assertions(3);
expect(() => {
PieWrapper({ pieSort: null, pieSortValues: null });
}).not.toThrow();
// Should sort the arcs the same order as the input data
// The default pieSortValues sorts data by descending values
const A = 1;
const B = 20;
shallow(
<Pie data={[A, B]} pieSortValues={null}>
{({ arcs }) => {
expect(arcs[0]).toMatchObject({ value: A, index: 0 });
expect(arcs[1]).toMatchObject({ value: B, index: 1 });
return null;
}}
</Pie>,
);
});
test('it should break on invalid sort callbacks', () => {
expect(() => PieWrapper({ pieSort: 12 })).toThrow();
expect(() => PieWrapper({ pieSortValues: 12 })).toThrow();
});
test('it should have the .visx-pie-arcs-group class', () => {
expect(PieWrapper().prop('className')).toBe('visx-pie-arcs-group');
});
test('it should contain paths', () => {
expect(PieWrapper().find('path').length).toBeGreaterThan(0);
});
test('it should take a children as function prop', () => {
const fn = jest.fn();
PieChildren({ children: fn });
expect(fn).toHaveBeenCalled();
});
test('it should accept a custom fill function', () => {
const paths = PieWrapper({
fill: (datum: PieArcDatum<Datum>) => datum.data.color,
}).find('path');
expect(paths.at(0).prop('fill')).toBe('blue');
expect(paths.at(1).prop('fill')).toBe('red');
});
test('it should accept a constant string fill value', () => {
const paths = PieWrapper({
fill: 'purple',
}).find('path');
expect(paths.at(0).prop('fill')).toBe('purple');
expect(paths.at(1).prop('fill')).toBe('purple');
});
test('it should call children function with { arcs, path, pie }', () => {
const fn = jest.fn();
PieChildren({ children: fn });
const args = fn.mock.calls[0][0];
const keys = Object.keys(args);
expect(keys).toContain('path');
expect(keys).toContain('arcs');
expect(keys).toContain('pie');
});
});
|
8,079 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/Polygon.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { Polygon } from '../src';
import { PolygonProps } from '../src/shapes/Polygon';
const PolygonWrapper = (restProps = {}) => shallow(<Polygon size={10} sides={6} {...restProps} />);
const PolygonChildren = ({ children, ...restProps }: Partial<PolygonProps>) =>
shallow(
<Polygon size={10} sides={6} {...restProps}>
{children}
</Polygon>,
);
describe('<Polygon />', () => {
it('should be defined', () => {
expect(Polygon).toBeDefined();
});
it('should render an octagon', () => {
const wrapper = PolygonWrapper({ sides: 8, size: 25 });
const polygon = wrapper.find('polygon');
const points = polygon.props().points!.split(' ');
expect(points).toHaveLength(8);
});
it('should add classname', () => {
const wrapper = PolygonWrapper({ sides: 6, size: 25, className: 'a-polygon' });
expect(wrapper.prop('className')).toBe('visx-polygon a-polygon');
});
it('should add onClick handler', () => {
const fn = jest.fn();
const wrapper = PolygonWrapper({
sides: 6,
size: 25,
className: 'a-polygon',
onClick: fn,
});
wrapper.simulate('click');
expect(fn).toHaveBeenCalled();
});
test('it should take a children as function prop', () => {
const fn = jest.fn();
PolygonChildren({ children: fn, sides: 8, size: 25 });
expect(fn).toHaveBeenCalled();
});
test('it should call children function with { points }', () => {
const fn = jest.fn();
PolygonChildren({ children: fn, sides: 8, size: 25 });
const args = fn.mock.calls[0][0];
const keys = Object.keys(args);
expect(keys).toContain('points');
expect(args.points).toHaveLength(8);
});
});
|
8,080 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/Stack.test.tsx | import { Stack } from '../src';
describe('<Stack />', () => {
test('it should be defined', () => {
expect(Stack).toBeDefined();
});
});
|
8,081 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/stackOffset.test.ts | import { stackOffset, STACK_OFFSETS, STACK_OFFSET_NAMES } from '../src';
describe('STACK_OFFSETS', () => {
test('it should be defined', () => {
expect(STACK_OFFSETS).toBeDefined();
});
test("it's keys should match STACK_OFFSET_NAMES", () => {
expect(Object.keys(STACK_OFFSETS)).toEqual(STACK_OFFSET_NAMES);
});
});
describe('stackOffset()', () => {
test('it should default to d3.stackOffsetNone', () => {
// @ts-expect-error allow invalid input
const offset = stackOffset('x');
expect(offset).toEqual(STACK_OFFSETS.none);
});
test('it should return corresponding offset for given offset name', () => {
const offset = stackOffset('expand');
expect(offset).toEqual(STACK_OFFSETS.expand);
});
});
|
8,082 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/stackOrder.test.ts | import { stackOrder, STACK_ORDERS, STACK_ORDER_NAMES } from '../src';
describe('STACK_ORDERS', () => {
test('it should be defined', () => {
expect(STACK_ORDERS).toBeDefined();
});
test("it's keys should match STACK_ORDER_NAMES", () => {
expect(Object.keys(STACK_ORDERS)).toEqual(STACK_ORDER_NAMES);
});
});
describe('stackOrders()', () => {
test('it should default to d3.stackOrderNone', () => {
// @ts-expect-error allow invalid input
const offset = stackOrder('x');
expect(offset).toEqual(STACK_ORDERS.none);
});
test('it should return corresponding order for given order name', () => {
const offset = stackOrder('ascending');
expect(offset).toEqual(STACK_ORDERS.ascending);
});
});
|
8,083 | 0 | petrpan-code/airbnb/visx/packages/visx-shape | petrpan-code/airbnb/visx/packages/visx-shape/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
8,084 | 0 | petrpan-code/airbnb/visx/packages/visx-shape/test | petrpan-code/airbnb/visx/packages/visx-shape/test/utils/D3ShapeFactories.test.ts | import { curveBasis, stackOrderDescending, stackOffsetExpand } from 'd3-shape';
import { arc, area, pie, line, radialLine, stack } from '../../src/util/D3ShapeFactories';
describe('D3ShapeFactories', () => {
describe('arc()', () => {
it('innerRadius', () => {
expect(arc({ innerRadius: 1 }).innerRadius()({})).toBe(1);
});
it('outerRadius', () => {
expect(arc({ outerRadius: 1 }).outerRadius()({})).toBe(1);
});
it('cornerRadius', () => {
expect(arc({ cornerRadius: 1 }).cornerRadius()({})).toBe(1);
});
it('startAngle', () => {
expect(arc({ startAngle: 1 }).startAngle()({})).toBe(1);
});
it('endAngle', () => {
expect(arc({ endAngle: 1 }).endAngle()({})).toBe(1);
});
it('padAngle', () => {
expect(arc({ padAngle: 1 }).padAngle()({})).toBe(1);
});
it('padRadius', () => {
expect(arc({ padRadius: 1 }).padRadius()!({})).toBe(1);
});
});
describe('area()', () => {
it('x', () => {
expect(area({ x: 1 }).x()({}, 0, [])).toBe(1);
});
it('x0', () => {
expect(area({ x0: 1 }).x0()({}, 0, [])).toBe(1);
});
it('x1', () => {
expect(area({ x1: 1 }).x1()!({}, 0, [])).toBe(1);
});
it('y', () => {
expect(area({ y: 1 }).y()({}, 0, [])).toBe(1);
});
it('y0', () => {
expect(area({ y0: 1 }).y0()({}, 0, [])).toBe(1);
});
it('y1', () => {
expect(area({ y1: 1 }).y1()!({}, 0, [])).toBe(1);
});
it('defined', () => {
expect(area({ defined: () => true }).defined()({}, 0, [])).toBe(true);
});
it('curve', () => {
expect(area({ curve: curveBasis }).curve()).toEqual(curveBasis);
});
});
describe('line()', () => {
it('x', () => {
expect(line({ x: 1 }).x()({}, 0, [])).toBe(1);
});
it('y', () => {
expect(line({ y: 1 }).y()({}, 0, [])).toBe(1);
});
it('defined', () => {
expect(line({ defined: () => true }).defined()({}, 0, [])).toBe(true);
});
it('curve', () => {
expect(line({ curve: curveBasis }).curve()).toEqual(curveBasis);
});
});
describe('pie()', () => {
it('startAngle', () => {
expect(pie({ startAngle: 1 }).startAngle()([])).toBe(1);
});
it('endAngle', () => {
expect(pie({ endAngle: 1 }).endAngle()([])).toBe(1);
});
it('padAngle', () => {
expect(pie({ padAngle: 1 }).padAngle()([])).toBe(1);
});
it('value', () => {
expect(pie({ value: () => 1 }).value()({}, 1, [])).toBe(1);
});
it('sort', () => {
expect(pie({ sort: () => 1 }).sort()!({}, {})).toBe(1);
});
it('sortValues', () => {
expect(pie({ sortValues: () => 1 }).sortValues()!(2, 1)).toBe(1);
});
});
describe('radialLine()', () => {
it('angle', () => {
expect(radialLine({ angle: 1 }).angle()({}, 1, [])).toBe(1);
});
it('radius', () => {
expect(radialLine({ radius: 1 }).radius()({}, 1, [])).toBe(1);
});
it('defined', () => {
expect(radialLine({ defined: () => true }).defined()({}, 0, [])).toBe(true);
});
it('curve', () => {
expect(radialLine({ curve: curveBasis }).curve()).toEqual(curveBasis);
});
});
describe('stack()', () => {
it('keys', () => {
expect(stack({ keys: ['a', 'b', 'c'] }).keys()([])).toEqual(['a', 'b', 'c']);
});
it('value', () => {
expect(stack({ value: () => 1 }).value()({}, '', 1, [])).toBe(1);
});
it('order', () => {
expect(stack({ order: 'descending' }).order()).toEqual(stackOrderDescending);
});
it('offset', () => {
expect(stack({ offset: 'expand' }).offset()).toEqual(stackOffsetExpand);
});
});
});
|
8,085 | 0 | petrpan-code/airbnb/visx/packages/visx-shape/test | petrpan-code/airbnb/visx/packages/visx-shape/test/utils/getBandwidth.test.ts | import { scaleBand, scalePoint, scaleOrdinal } from '@visx/scale';
import getBandwidth from '../../src/util/getBandwidth';
describe('getBandwidth()', () => {
it('returns bandwidth for scales that natively supports', () => {
const scale1 = scaleBand({ domain: ['bacon', 'egg'], range: [0, 100] });
expect(getBandwidth(scale1)).toBe(50);
const scale2 = scalePoint({ domain: ['bacon', 'egg'], range: [0, 100] });
expect(getBandwidth(scale2)).toBe(0);
});
it('otherwise compute band from domain and range', () => {
const scale = scaleOrdinal({ domain: ['bacon', 'egg'], range: [0, 100] });
expect(getBandwidth(scale)).toBe(50);
});
});
|
8,095 | 0 | petrpan-code/airbnb/visx/packages/visx-stats | petrpan-code/airbnb/visx/packages/visx-stats/test/BoxPlot.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { scaleLinear } from '@visx/scale';
import { BoxPlot, computeStats } from '../src';
const data = [1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 1];
const { boxPlot: boxPlotData } = computeStats(data);
const { min, firstQuartile, median, thirdQuartile, max, outliers } = boxPlotData;
const valueScale = scaleLinear<number>({
range: [10, 0],
round: true,
domain: [0, 10],
});
describe('<BoxPlot />', () => {
test('it should be defined', () => {
expect(BoxPlot).toBeDefined();
});
test('it should have className .visx-boxplot', () => {
const wrapper = shallow(
<BoxPlot
min={min}
max={max}
left={0}
firstQuartile={firstQuartile}
thirdQuartile={thirdQuartile}
median={median}
boxWidth={100}
valueScale={valueScale}
outliers={outliers}
/>,
);
expect(wrapper.prop('className')).toBe('visx-boxplot');
});
test('it should render 5 lines and one rectangle', () => {
const wrapper = shallow(
<BoxPlot
min={min}
max={max}
left={0}
firstQuartile={firstQuartile}
thirdQuartile={thirdQuartile}
median={median}
boxWidth={100}
valueScale={valueScale}
outliers={outliers}
/>,
);
expect(wrapper.find('line')).toHaveLength(5);
expect(wrapper.find('rect')).toHaveLength(1);
});
});
|
8,096 | 0 | petrpan-code/airbnb/visx/packages/visx-stats | petrpan-code/airbnb/visx/packages/visx-stats/test/ViolinPlot.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { scaleLinear } from '@visx/scale';
import { ViolinPlot, computeStats } from '../src';
const data = [1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 1];
const { binData } = computeStats(data);
const valueScale = scaleLinear({
range: [10, 0],
round: true,
domain: [0, 10],
});
describe('<VoilinPlot />', () => {
test('it should be defined', () => {
expect(ViolinPlot).toBeDefined();
});
test('it should have className .visx-violin', () => {
const wrapper = shallow(
<ViolinPlot data={binData} left={3} width={100} valueScale={valueScale} />,
);
expect(wrapper.prop('className')).toBe('visx-violin');
});
test('it should render one path element', () => {
const wrapper = shallow(
<ViolinPlot data={binData} left={3} width={100} valueScale={valueScale} />,
);
expect(wrapper.find('path')).toHaveLength(1);
});
});
|
8,097 | 0 | petrpan-code/airbnb/visx/packages/visx-stats | petrpan-code/airbnb/visx/packages/visx-stats/test/computeStats.test.ts | import { computeStats } from '../src';
const data = [1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 1];
const edgeCaseData = [10000, 2400, 10000, 10000];
describe('computeStats', () => {
test('it should be defined', () => {
expect(computeStats).toBeDefined();
});
test('it should have boxPlot and binData', () => {
const stats = computeStats(data);
expect(stats.boxPlot).toBeDefined();
expect(stats.binData).toBeDefined();
});
test('it should have boxPlot and binData when first and third quartile are equal', () => {
const stats = computeStats(edgeCaseData);
expect(stats.boxPlot).toBeDefined();
expect(stats.binData).toBeDefined();
});
test('min/max should match the dataset when there are no outliers', () => {
const stats = computeStats(edgeCaseData);
expect(stats.boxPlot.min).toBe(Math.min(...edgeCaseData));
expect(stats.boxPlot.max).toBe(Math.max(...edgeCaseData));
});
});
|
8,098 | 0 | petrpan-code/airbnb/visx/packages/visx-stats | petrpan-code/airbnb/visx/packages/visx-stats/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
8,108 | 0 | petrpan-code/airbnb/visx/packages/visx-text | petrpan-code/airbnb/visx/packages/visx-text/test/Text.test.tsx | import React from 'react';
import { render } from '@testing-library/react';
import { renderHook } from '@testing-library/react-hooks';
import '@testing-library/jest-dom';
import { Text, getStringWidth, useText } from '../src';
import { addMock, removeMock } from './svgMock';
describe('getStringWidth()', () => {
it('should be defined', () => {
expect(getStringWidth).toBeDefined();
});
});
describe('<Text />', () => {
beforeEach(addMock);
afterEach(removeMock);
it('should be defined', () => {
expect(Text).toBeDefined();
});
it('Does not wrap long text if enough width', () => {
const {
result: {
current: { wordsByLines },
},
} = renderHook(() =>
useText({
width: 300,
style: { fontFamily: 'Courier' },
children: 'This is really long text',
}),
);
expect(wordsByLines).toHaveLength(1);
});
it('Wraps text if not enough width', () => {
const {
result: {
current: { wordsByLines },
},
} = renderHook(() =>
useText({
width: 200,
style: { fontFamily: 'Courier' },
children: 'This is really long text',
}),
);
expect(wordsByLines).toHaveLength(2);
});
it('Does not wrap text if there is enough width', () => {
const {
result: {
current: { wordsByLines },
},
} = renderHook(() =>
useText({
width: 300,
style: { fontSize: '2em', fontFamily: 'Courier' },
children: 'This is really long text',
}),
);
expect(wordsByLines).toHaveLength(1);
});
it('Does not perform word length calculation if width or scaleToFit props not set', () => {
const {
result: {
current: { wordsByLines },
},
} = renderHook(() =>
useText({
children: 'This is really long text',
}),
);
expect(wordsByLines).toHaveLength(1);
expect(wordsByLines[0].width).toBeUndefined();
});
it('Render 0 success when specify the width', () => {
const { container } = render(
<Text x={0} y={0} width={30}>
0
</Text>,
);
const text = container.querySelector('tspan');
expect(text?.textContent).toBe('0');
});
it('Render 0 success when not specify the width', () => {
const { container } = render(
<Text x={0} y={0}>
0
</Text>,
);
const text = container.querySelector('tspan');
expect(text?.textContent).toBe('0');
});
it('Render text when x or y is a percentage', () => {
const { container } = render(
<Text x="50%" y="50%">
anything
</Text>,
);
const text = container.querySelector('tspan');
expect(text?.textContent).toBe('anything');
});
it("Don't Render text when x or y is NaN", () => {
const { container } = render(
<Text x={NaN} y={10}>
anything
</Text>,
);
const text = container.querySelector('tspan');
expect(text).toBeNull();
});
it('Render text when children 0 is a number', () => {
const num = 0;
const { container } = render(
<Text x={0} y={0}>
{num}
</Text>,
);
const text = container.querySelector('tspan');
expect(text?.textContent).toBe('0');
});
it('Applies transform if scaleToFit is set', () => {
const {
result: {
current: { transform },
},
} = renderHook(() =>
useText({
width: 300,
scaleToFit: true,
style: { fontFamily: 'Courier' },
children: 'This is really long text',
}),
);
expect(transform).toBe('matrix(1.25, 0, 0, 1.25, 0, 0)');
});
it("Does not scale above 1 when scaleToFit is set to 'shrink-only'", () => {
const {
result: {
current: { transform },
},
} = renderHook(() =>
useText({
width: 300,
scaleToFit: 'shrink-only',
style: { fontFamily: 'Courier' },
children: 'This is really long text',
}),
);
expect(transform).toBe('matrix(1, 0, 0, 1, 0, 0)');
});
it("Shrinks long text when scaleToFit is set to 'shrink-only'", () => {
const {
result: {
current: { transform },
},
} = renderHook(() =>
useText({
width: 30,
scaleToFit: 'shrink-only',
style: { fontFamily: 'Courier' },
children: 'This is really long text',
}),
);
expect(transform).toBe('matrix(0.125, 0, 0, 0.125, 0, 0)');
});
it('Applies transform if angle is given', () => {
const { container } = render(
<Text width={300} angle={45} style={{ fontFamily: 'Courier' }}>
This is really long text
</Text>,
);
const text = container.querySelector('text');
expect(text).toHaveAttribute('transform', 'rotate(45, 0, 0)');
});
it('Offsets vertically if verticalAnchor is given', () => {
let { container } = render(
<Text width={200} style={{ fontFamily: 'Courier' }}>
This is really long text
</Text>,
);
const getVerticalOffset = (c: HTMLElement) => c?.querySelector('tspan')?.getAttribute('dy');
expect(getVerticalOffset(container)).toBe('-1em');
({ container } = render(
<Text width={200} verticalAnchor="middle" style={{ fontFamily: 'Courier' }}>
This is really long text
</Text>,
));
expect(getVerticalOffset(container)).toBe('-0.145em');
({ container } = render(
<Text width={200} verticalAnchor="start" style={{ fontFamily: 'Courier' }}>
This is really long text
</Text>,
));
expect(getVerticalOffset(container)).toBe('0.71em');
});
});
|
8,110 | 0 | petrpan-code/airbnb/visx/packages/visx-text | petrpan-code/airbnb/visx/packages/visx-text/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
8,118 | 0 | petrpan-code/airbnb/visx/packages/visx-threshold | petrpan-code/airbnb/visx/packages/visx-threshold/test/Threshold.test.tsx | import React from 'react';
import { render } from 'enzyme';
import { Threshold } from '../src';
const data = [
{ x: 1, y0: 6, y1: 10 },
{ x: 2, y0: 7, y1: 11 },
];
describe('<Threshold />', () => {
it('should be defined', () => {
expect(Threshold).toBeDefined();
});
it('should render the path', () => {
const wrapper = render(
<svg>
<Threshold
id={`${Math.random()}`}
data={data}
x={(d) => d.x}
y0={(d) => d.y0}
y1={(d) => d.y1}
clipAboveTo={0}
clipBelowTo={100}
belowAreaProps={{
fill: 'violet',
fillOpacity: 0.4,
}}
aboveAreaProps={{
fill: 'green',
fillOpacity: 0.4,
}}
/>
</svg>,
);
expect(wrapper.find('g.visx-threshold')).toHaveLength(1);
expect(wrapper.find('path')).toHaveLength(4);
});
it('supports accessors for clipping', () => {
const wrapper = render(
<svg>
<Threshold
id={`${Math.random()}`}
data={data}
x={(d) => d.x}
y0={(d) => d.y0}
y1={(d) => d.y1}
clipAboveTo={() => 0}
clipBelowTo={() => 100}
belowAreaProps={{
fill: 'violet',
fillOpacity: 0.4,
}}
aboveAreaProps={{
fill: 'green',
fillOpacity: 0.4,
}}
/>
</svg>,
);
expect(wrapper.find('g.visx-threshold')).toHaveLength(1);
expect(wrapper.find('path')).toHaveLength(4);
});
});
|
8,119 | 0 | petrpan-code/airbnb/visx/packages/visx-threshold | petrpan-code/airbnb/visx/packages/visx-threshold/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
8,132 | 0 | petrpan-code/airbnb/visx/packages/visx-tooltip | petrpan-code/airbnb/visx/packages/visx-tooltip/test/Portal.test.tsx | import { Portal } from '../src';
describe('Portal', () => {
test('it should be defined', () => {
expect(Portal).toBeDefined();
});
});
|
8,133 | 0 | petrpan-code/airbnb/visx/packages/visx-tooltip | petrpan-code/airbnb/visx/packages/visx-tooltip/test/Tooltip.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { Tooltip, defaultStyles } from '../src';
describe('<Tooltip />', () => {
test('it should be defined', () => {
expect(Tooltip).toBeDefined();
});
it('should render with the default styles', () => {
const wrapper = shallow(<Tooltip>Hello</Tooltip>);
const styles = wrapper.props().style;
Object.entries(defaultStyles).forEach(([key, value]) => {
expect(styles[key]).toBe(value);
});
});
it('should render with no default styles', () => {
const wrapper = shallow(<Tooltip unstyled>Hello</Tooltip>);
const styles = wrapper.props().style;
Object.keys(defaultStyles).forEach((key) => {
expect(styles[key]).toBeUndefined();
});
});
it('should overwrite default styles when given the style prop', () => {
const newStyles: React.CSSProperties = {
position: 'relative',
backgroundColor: 'green',
color: 'red',
padding: '.8rem .8rem',
borderRadius: '13px',
fontSize: '17px',
boxShadow: '0 2px 3px rgba(133,133,133,0.5)',
lineHeight: '2em',
};
const wrapper = shallow(<Tooltip style={newStyles} />);
const styles = wrapper.props().style;
Object.entries(newStyles).forEach(([key, value]) => {
expect(styles[key]).toBe(value);
});
});
});
|
8,134 | 0 | petrpan-code/airbnb/visx/packages/visx-tooltip | petrpan-code/airbnb/visx/packages/visx-tooltip/test/TooltipWithBounds.test.tsx | /* eslint-disable @typescript-eslint/no-explicit-any */
import React from 'react';
import { shallow } from 'enzyme';
import { TooltipWithBounds, defaultStyles } from '../src';
describe('<TooltipWithBounds />', () => {
test('it should be defined', () => {
expect(TooltipWithBounds).toBeDefined();
});
it('should render the Tooltip with default styles by default', () => {
const wrapper = shallow(<TooltipWithBounds>Hello</TooltipWithBounds>, {
disableLifecycleMethods: true,
}).dive();
const styles = wrapper.find('Tooltip').props().style as any;
Object.entries(defaultStyles).forEach(([key, value]) => {
expect(styles[key]).toBe(value);
});
});
it('should render the tooltip without default styles if unstyled is set to true', () => {
const wrapper = shallow(<TooltipWithBounds unstyled>Hello</TooltipWithBounds>, {
disableLifecycleMethods: true,
}).dive();
const styles = wrapper.find('Tooltip').props().style as any;
Object.keys(defaultStyles).forEach((key) => {
expect(styles[key]).toBeUndefined();
});
});
});
|
8,135 | 0 | petrpan-code/airbnb/visx/packages/visx-tooltip | petrpan-code/airbnb/visx/packages/visx-tooltip/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
8,136 | 0 | petrpan-code/airbnb/visx/packages/visx-tooltip | petrpan-code/airbnb/visx/packages/visx-tooltip/test/useTooltip.test.tsx | import { useTooltip } from '../src';
describe('useTooltip()', () => {
test('it should be defined', () => {
expect(useTooltip).toBeDefined();
});
});
|
8,137 | 0 | petrpan-code/airbnb/visx/packages/visx-tooltip | petrpan-code/airbnb/visx/packages/visx-tooltip/test/useTooltipInPortal.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { ResizeObserver } from '@juggle/resize-observer';
import { useTooltipInPortal } from '../src';
import { UseTooltipPortalOptions } from '../src/hooks/useTooltipInPortal';
interface TooltipWithZIndexProps {
zIndexOption?: UseTooltipPortalOptions['zIndex'];
zIndexProp?: UseTooltipPortalOptions['zIndex'];
}
const TooltipWithZIndex = ({ zIndexOption, zIndexProp }: TooltipWithZIndexProps) => {
const { TooltipInPortal } = useTooltipInPortal({
polyfill: ResizeObserver,
zIndex: zIndexOption,
});
return <TooltipInPortal zIndex={zIndexProp}>Hello</TooltipInPortal>;
};
describe('useTooltipInPortal()', () => {
test('it should be defined', () => {
expect(useTooltipInPortal).toBeDefined();
});
it('should pass zIndex prop from options to Portal', () => {
const wrapper = shallow(<TooltipWithZIndex zIndexOption={1} />, {
disableLifecycleMethods: true,
}).dive();
const zIndex = wrapper.find('Portal').prop('zIndex');
expect(zIndex).toBe(1);
});
it('should pass zIndex prop from component to Portal', () => {
const wrapper = shallow(
<TooltipWithZIndex zIndexOption={1} zIndexProp="var(--tooltip-zindex)" />,
{
disableLifecycleMethods: true,
},
).dive();
const zIndex = wrapper.find('Portal').prop('zIndex');
expect(zIndex).toBe('var(--tooltip-zindex)');
});
});
|
8,138 | 0 | petrpan-code/airbnb/visx/packages/visx-tooltip | petrpan-code/airbnb/visx/packages/visx-tooltip/test/withTooltip.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { withTooltip } from '../src';
const DummyComponent = () => null;
const DummyComponentWithDefaultTooltip = withTooltip(DummyComponent);
const DummyComponentWithCustomContainerPropsTooltip = withTooltip(DummyComponent, {
style: { position: 'static' },
});
const DummyComponentWithNoContainerTooltip = withTooltip(
DummyComponent,
undefined,
(children) => children,
);
describe('withTooltip()', () => {
test('it should be defined', () => {
expect(withTooltip).toBeDefined();
});
test('it should render a default container', () => {
const wrapper = shallow(<DummyComponentWithDefaultTooltip />);
expect(wrapper.find('div')).toHaveLength(1);
expect(wrapper.find('div').first().prop('style')).toEqual({
position: 'relative',
width: 'inherit',
height: 'inherit',
});
expect(wrapper.find(DummyComponent)).toHaveLength(1);
});
test('it should pass custom props to the container', () => {
const wrapper = shallow(<DummyComponentWithCustomContainerPropsTooltip />);
expect(wrapper.find('div')).toHaveLength(1);
expect(wrapper.find('div').first().prop('style')).toEqual({
position: 'static',
});
expect(wrapper.find(DummyComponent)).toHaveLength(1);
});
test('it should render with a custom container', () => {
const wrapper = shallow(<DummyComponentWithNoContainerTooltip />);
expect(wrapper.find('div')).toHaveLength(0);
expect(wrapper.find(DummyComponent)).toHaveLength(1);
});
});
|
8,148 | 0 | petrpan-code/airbnb/visx/packages/visx-vendor | petrpan-code/airbnb/visx/packages/visx-vendor/test/d3-array.test.ts | /* This test verifies that these modules and types are exported correctly */
import {
// @ts-expect-error Make sure invalid imports fail:
INVALID_TYPE,
Adder,
Bin,
Bisector,
bin,
bisect,
bisectCenter,
bisectLeft,
bisectRight,
bisector,
count,
} from '@visx/vendor/d3-array';
describe('d3-array', () => {
it('exports valid functions', () => {
expect(bisect).toBeInstanceOf(Function);
});
});
|
8,149 | 0 | petrpan-code/airbnb/visx/packages/visx-vendor | petrpan-code/airbnb/visx/packages/visx-vendor/test/d3-color.test.ts | /* This test verifies that these modules and types are exported correctly */
import {
// @ts-expect-error Make sure invalid imports fail:
INVALID_TYPE,
color,
cubehelix,
lab,
gray,
hcl,
HCLColor,
LabColor,
lch,
RGBColor,
} from '@visx/vendor/d3-color';
describe('d3-color', () => {
it('exports valid functions', () => {
expect(color).toBeInstanceOf(Function);
});
});
|
8,150 | 0 | petrpan-code/airbnb/visx/packages/visx-vendor | petrpan-code/airbnb/visx/packages/visx-vendor/test/d3-format.test.ts | /* This test verifies that these modules and types are exported correctly */
import {
// @ts-expect-error Make sure invalid imports fail:
INVALID_TYPE,
format,
formatDefaultLocale,
formatLocale,
formatPrefix,
formatSpecifier,
FormatSpecifierObject,
} from '@visx/vendor/d3-format';
describe('d3-format', () => {
it('exports valid functions', () => {
expect(format).toBeInstanceOf(Function);
});
});
|
8,151 | 0 | petrpan-code/airbnb/visx/packages/visx-vendor | petrpan-code/airbnb/visx/packages/visx-vendor/test/d3-geo.test.ts | /* This test verifies that these modules and types are exported correctly */
import {
// @ts-expect-error Make sure invalid imports fail:
INVALID_TYPE,
ExtendedFeature,
ExtendedFeatureCollection,
ExtendedGeometryCollection,
GeoCircleGenerator,
GeoConicProjection,
GeoContext,
GeoGeometryObjects,
GeoGraticuleGenerator,
GeoIdentityTransform,
GeoPath,
GeoPermissibleObjects,
GeoProjection,
GeoRawProjection,
GeoRotation,
GeoSphere,
GeoStreamWrapper,
GeoStream,
GeoTransformPrototype,
geoAlbers,
geoAlbersUsa,
geoArea,
geoAzimuthalEqualArea,
geoAzimuthalEqualAreaRaw,
geoAzimuthalEquidistant,
geoAzimuthalEquidistantRaw,
geoBounds,
} from '@visx/vendor/d3-geo';
describe('d3-geo', () => {
it('exports valid functions', () => {
expect(geoBounds).toBeInstanceOf(Function);
});
});
|
8,152 | 0 | petrpan-code/airbnb/visx/packages/visx-vendor | petrpan-code/airbnb/visx/packages/visx-vendor/test/d3-interpolate.test.ts | /* This test verifies that these modules and types are exported correctly */
import {
// @ts-expect-error Make sure invalid imports fail:
INVALID_TYPE,
interpolate,
NumberArray,
} from '@visx/vendor/d3-interpolate';
describe('d3-interpolate', () => {
it('exports valid functions', () => {
expect(interpolate).toBeInstanceOf(Function);
});
});
|
8,153 | 0 | petrpan-code/airbnb/visx/packages/visx-vendor | petrpan-code/airbnb/visx/packages/visx-vendor/test/d3-scale.test.ts | /* This test verifies that these modules and types are exported correctly */
import {
// @ts-expect-error Make sure invalid imports fail:
INVALID_TYPE,
InterpolatorFactory,
NumberValue,
ScaleBand,
ScaleContinuousNumeric,
ScaleDiverging,
ScaleIdentity,
ScaleLinear,
ScaleLogarithmic,
ScaleOrdinal,
ScalePoint,
ScalePower,
ScaleQuantile,
ScaleQuantize,
ScaleRadial,
ScaleSequential,
ScaleSequentialBase,
ScaleSequentialQuantile,
ScaleSymLog,
ScaleThreshold,
ScaleTime,
UnknownReturnType,
scaleBand,
scaleDiverging,
scaleDivergingLog,
scaleDivergingPow,
scaleDivergingSqrt,
scaleDivergingSymlog,
scaleIdentity,
scaleImplicit,
scaleLinear,
scaleLog,
scaleOrdinal,
scalePoint,
scalePow,
scaleQuantile,
scaleQuantize,
scaleRadial,
scaleSequential,
scaleSequentialLog,
scaleSequentialPow,
scaleSequentialQuantile,
scaleSequentialSqrt,
scaleSequentialSymlog,
scaleSqrt,
scaleSymlog,
scaleThreshold,
scaleTime,
scaleUtc,
tickFormat,
} from '@visx/vendor/d3-scale';
describe('d3-scale', () => {
it('exports valid functions', () => {
expect(scaleLinear).toBeInstanceOf(Function);
expect(scaleBand).toBeInstanceOf(Function);
});
});
|
8,154 | 0 | petrpan-code/airbnb/visx/packages/visx-vendor | petrpan-code/airbnb/visx/packages/visx-vendor/test/d3-time-format.test.ts | /* This test verifies that these modules and types are exported correctly */
import {
// @ts-expect-error Make sure invalid imports fail:
INVALID_TYPE,
timeFormat,
timeParse,
timeFormatLocale,
TimeLocaleObject,
utcFormat,
isoFormat,
} from '@visx/vendor/d3-time-format';
describe('d3-time-format', () => {
it('exports valid functions', () => {
expect(timeParse).toBeInstanceOf(Function);
expect(timeFormat).toBeInstanceOf(Function);
});
});
|
8,155 | 0 | petrpan-code/airbnb/visx/packages/visx-vendor | petrpan-code/airbnb/visx/packages/visx-vendor/test/d3-time.test.ts | /* This test verifies that these modules and types are exported correctly */
import {
// @ts-expect-error Make sure invalid imports fail:
INVALID_TYPE,
CountableTimeInterval,
TimeInterval,
timeDay,
timeInterval,
} from '@visx/vendor/d3-time';
describe('d3-time', () => {
it('exports valid functions', () => {
expect(timeDay).toBeInstanceOf(Function);
expect(timeInterval).toBeInstanceOf(Function);
});
});
|
8,156 | 0 | petrpan-code/airbnb/visx/packages/visx-vendor | petrpan-code/airbnb/visx/packages/visx-vendor/test/internmap.test.ts | /* This test verifies that these modules and types are exported correctly */
import { InternSet, InternMap } from '@visx/vendor/internmap';
describe('internmap', () => {
it('exports valid classes', () => {
expect(InternSet).toBeDefined();
expect(InternMap).toBeDefined();
});
});
|
8,162 | 0 | petrpan-code/airbnb/visx/packages/visx-visx | petrpan-code/airbnb/visx/packages/visx-visx/test/index.test.ts | import * as visx from '../src';
describe('visx', () => {
it('should be defined', () => {
expect(visx).toBeDefined();
});
it('should export @visx/annotation', () => {
expect(visx.Annotation.Annotation).toBeDefined();
});
it('should export @visx/axis', () => {
expect(visx.Axis.Axis).toBeDefined();
});
it('should export @visx/bounds', () => {
expect(visx.Bounds.withBoundingRects).toBeDefined();
});
it('should export @visx/clip-path', () => {
expect(visx.ClipPath.ClipPath).toBeDefined();
});
it('should export @visx/curve', () => {
expect(visx.Curve.curveBasis).toBeDefined();
});
it('should export @visx/drag', () => {
expect(visx.Drag.Drag).toBeDefined();
});
it('should export @visx/event', () => {
expect(visx.Event.localPoint).toBeDefined();
});
it('should export @visx/geo', () => {
expect(visx.Geo.Albers).toBeDefined();
});
it('should export @visx/glyph', () => {
expect(visx.Glyph.Glyph).toBeDefined();
});
it('should export @visx/gradient', () => {
expect(visx.Gradient.LinearGradient).toBeDefined();
});
it('should export @visx/grid', () => {
expect(visx.Grid.Grid).toBeDefined();
});
it('should export @visx/group', () => {
expect(visx.Group.Group).toBeDefined();
});
it('should export @visx/heatmap', () => {
expect(visx.Heatmap.HeatmapRect).toBeDefined();
});
it('should export @visx/hierarchy', () => {
expect(visx.Hierarchy.Tree).toBeDefined();
});
it('should export @visx/legend', () => {
expect(visx.Legend.Legend).toBeDefined();
});
it('should export @visx/marker', () => {
expect(visx.Marker.Marker).toBeDefined();
});
it('should export @visx/mock-data', () => {
expect(visx.MockData.genDateValue).toBeDefined();
});
it('should export @visx/network', () => {
expect(visx.Network.Graph).toBeDefined();
});
it('should export @visx/pattern', () => {
expect(visx.Pattern.Pattern).toBeDefined();
});
it('should export @visx/point', () => {
expect(visx.Point.Point).toBeDefined();
});
it('should export @visx/responsive', () => {
expect(visx.Responsive.withParentSize).toBeDefined();
});
it('should export @visx/scale', () => {
expect(visx.Scale.scaleBand).toBeDefined();
});
it('should export @visx/shape', () => {
expect(visx.Shape.Bar).toBeDefined();
});
it('should export @visx/text', () => {
expect(visx.Text.Text).toBeDefined();
});
it('should export @visx/tooltip', () => {
expect(visx.Tooltip.Tooltip).toBeDefined();
});
it('should export @visx/voronoi', () => {
expect(visx.Voronoi.voronoi).toBeDefined();
});
it('should export @visx/xychart', () => {
expect(visx.XYChart.XYChart).toBeDefined();
});
it('should export @visx/zoom', () => {
expect(visx.Zoom.Zoom).toBeDefined();
});
it('should export @visx/wordcloud', () => {
expect(visx.Wordcloud.Wordcloud).toBeDefined();
});
});
|
8,170 | 0 | petrpan-code/airbnb/visx/packages/visx-voronoi | petrpan-code/airbnb/visx/packages/visx-voronoi/test/VoronoiPolygon.test.tsx | import React from 'react';
import { shallow } from 'enzyme';
import { VoronoiPolygon } from '../src';
describe('<VoronoiPolygon />', () => {
const polygon: [number, number][] = new Array(3).fill(null).map((_, i) => [i, i]);
const props = { polygon };
test('it should be defined', () => {
expect(VoronoiPolygon).toBeDefined();
});
test('it should not render without a polygon', () => {
const wrapper = shallow(<VoronoiPolygon />);
expect(wrapper.type()).toBeNull();
});
test('it should render a path', () => {
const wrapper = shallow(<VoronoiPolygon {...props} />);
expect(wrapper.find('path')).toHaveLength(1);
});
test('it should set a d attribute based on the polygon prop', () => {
const wrapper = shallow(<VoronoiPolygon {...props} />);
const d = 'M0,0L1,1L2,2Z';
expect(wrapper.find('path').props().d).toEqual(d);
});
test('it should add extra (non-func) props to the path element', () => {
const wrapper = shallow(<VoronoiPolygon {...props} fill="orange" />);
expect(wrapper.find('path').props().fill).toBe('orange');
});
});
|
8,171 | 0 | petrpan-code/airbnb/visx/packages/visx-voronoi | petrpan-code/airbnb/visx/packages/visx-voronoi/test/tsconfig.json | {
"compilerOptions": {
"composite": false,
"emitDeclarationOnly": false,
"noEmit": true,
"rootDir": "."
},
"extends": "../../../tsconfig.options.json",
"include": ["**/*", "../types/**/*", "../../../types/**/*"],
"references": [
{
"path": ".."
}
]
}
|
8,172 | 0 | petrpan-code/airbnb/visx/packages/visx-voronoi | petrpan-code/airbnb/visx/packages/visx-voronoi/test/voronoi.test.ts | import { voronoi } from '../src';
const x = () => 123;
const y = () => 123;
describe('voronoi', () => {
test('it should be defined', () => {
expect(voronoi).toBeDefined();
});
test('x param should set voronoi x', () => {
const v = voronoi({ x });
expect(v.x()).toEqual(x);
});
test('y param should set voronoi y', () => {
const v = voronoi({ y });
expect(v.y()).toEqual(y);
});
test('width and height params should define extent', () => {
const width = 17;
const height = 99;
const v = voronoi({ width, height });
const extent = v.extent();
const endCoord = extent![1];
expect(endCoord[0]).toEqual(width + 1);
expect(endCoord[1]).toEqual(height + 1);
});
});
|
Subsets and Splits