Skip to content

Commit

Permalink
refactor and test InterfaceController
Browse files Browse the repository at this point in the history
  • Loading branch information
@GuillaumeRx
GuillaumeRx committed Jan 9, 2024
1 parent cada313 commit 490000b
Show file tree
Hide file tree
Showing 7 changed files with 330 additions and 245 deletions.
226 changes: 84 additions & 142 deletions packages/snaps-controllers/src/interface/InterfaceController.test.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,14 +5,11 @@ import {
getRestrictedInterfaceControllerMessenger,
getRootInterfaceControllerMessenger,
} from '../test-utils';
import {
INTERFACE_APPROVAL_TYPE,
InterfaceController,
} from './InterfaceController';
import { InterfaceController } from './InterfaceController';

describe('InterfaceController', () => {
describe('showInterface', () => {
it('can show a new interface', () => {
describe('createInterface', () => {
it('can create a new interface', () => {
const rootMessenger = getRootInterfaceControllerMessenger();
const controllerMessenger = getRestrictedInterfaceControllerMessenger(
rootMessenger,
Expand All @@ -23,35 +20,23 @@ describe('InterfaceController', () => {
messenger: controllerMessenger,
});

const content = form({ name: 'foo', children: [input({ name: 'bar' })] });
const components = form({
name: 'foo',
children: [input({ name: 'bar' })],
});

const id = interfaceController.showInterface(MOCK_SNAP_ID, content);

expect(rootMessenger.call).toHaveBeenCalledWith(
'ApprovalController:addRequest',
{
origin: MOCK_SNAP_ID,
id: expect.any(String),
type: INTERFACE_APPROVAL_TYPE,
requestData: {},
requestState: {
content,
state: {
foo: {
bar: null,
},
},
},
},
true,
);
const id = interfaceController.createInterface(MOCK_SNAP_ID, components);

const content = interfaceController.getInterfaceContent(MOCK_SNAP_ID, id);
const state = interfaceController.getInterfaceState(MOCK_SNAP_ID, id);

expect(id).toBeDefined();
expect(content).toStrictEqual(components);
expect(state).toStrictEqual({ foo: { bar: null } });
});
});

describe('updateInterface', () => {
it('can update an interface', () => {
describe('getInterfaceContent', () => {
it('gets the interface content', () => {
const rootMessenger = getRootInterfaceControllerMessenger();
const controllerMessenger = getRestrictedInterfaceControllerMessenger(
rootMessenger,
Expand All @@ -62,37 +47,18 @@ describe('InterfaceController', () => {
messenger: controllerMessenger,
});

const content = form({ name: 'foo', children: [input({ name: 'bar' })] });

const newContent = form({
const components = form({
name: 'foo',
children: [input({ name: 'baz' })],
children: [input({ name: 'bar' })],
});

const id = interfaceController.showInterface(MOCK_SNAP_ID, content);

const result = interfaceController.updateInterface(
MOCK_SNAP_ID,
id,
newContent,
);

expect(rootMessenger.call).toHaveBeenNthCalledWith(
2,
'ApprovalController:updateRequestState',
{
id,
requestState: {
content: newContent,
state: { foo: { baz: null } },
},
},
);
const id = interfaceController.createInterface(MOCK_SNAP_ID, components);

expect(result).toBeNull();
const content = interfaceController.getInterfaceContent(MOCK_SNAP_ID, id);
expect(content).toStrictEqual(components);
});

it('throws if the interface does not exist', () => {
it('throws if the snap requesting the interface is not the one that created it', () => {
const rootMessenger = getRootInterfaceControllerMessenger();
const controllerMessenger = getRestrictedInterfaceControllerMessenger(
rootMessenger,
Expand All @@ -103,14 +69,21 @@ describe('InterfaceController', () => {
messenger: controllerMessenger,
});

const content = form({ name: 'foo', children: [input({ name: 'bar' })] });
const components = form({
name: 'foo',
children: [input({ name: 'bar' })],
});

expect(() =>
interfaceController.updateInterface(MOCK_SNAP_ID, 'foo', content),
).toThrow("Interface with id 'foo' not found.");
const id = interfaceController.createInterface(MOCK_SNAP_ID, components);

interfaceController.getInterfaceContent(MOCK_SNAP_ID, id);

expect(() => interfaceController.getInterfaceContent('foo', id)).toThrow(
`Interface not created by foo.`,
);
});

it('throws if the interface is updated by another snap', () => {
it('throws if the interface does not exist', () => {
const rootMessenger = getRootInterfaceControllerMessenger();
const controllerMessenger = getRestrictedInterfaceControllerMessenger(
rootMessenger,
Expand All @@ -121,23 +94,14 @@ describe('InterfaceController', () => {
messenger: controllerMessenger,
});

const content = form({ name: 'foo', children: [input({ name: 'bar' })] });

const newContent = form({
name: 'foo',
children: [input({ name: 'baz' })],
});

const id = interfaceController.showInterface(MOCK_SNAP_ID, content);

expect(() =>
interfaceController.updateInterface('foo', id, newContent),
).toThrow('Interface not created by foo.');
interfaceController.getInterfaceContent(MOCK_SNAP_ID, 'test'),
).toThrow(`Interface with id 'test' not found.`);
});
});

describe('resolveInterface', () => {
it('resolves an interface', async () => {
describe('updateInterface', () => {
it('can update an interface', () => {
const rootMessenger = getRootInterfaceControllerMessenger();
const controllerMessenger = getRestrictedInterfaceControllerMessenger(
rootMessenger,
Expand All @@ -148,45 +112,34 @@ describe('InterfaceController', () => {
messenger: controllerMessenger,
});

const content = form({ name: 'foo', children: [input({ name: 'bar' })] });
const components = form({
name: 'foo',
children: [input({ name: 'bar' })],
});

const id = interfaceController.showInterface(MOCK_SNAP_ID, content);
const newContent = form({
name: 'foo',
children: [input({ name: 'baz' })],
});

const resolvedValue = 'foo';
const id = interfaceController.createInterface(MOCK_SNAP_ID, components);

const result = await interfaceController.resolveInterface(
const result = interfaceController.updateInterface(
MOCK_SNAP_ID,
id,
resolvedValue,
);

expect(rootMessenger.call).toHaveBeenNthCalledWith(
2,
'ApprovalController:acceptRequest',
id,
resolvedValue,
newContent,
);

expect(result).toBeNull();
});

it('throws if the interface does not exist', async () => {
const rootMessenger = getRootInterfaceControllerMessenger();
const controllerMessenger = getRestrictedInterfaceControllerMessenger(
rootMessenger,
true,
);
const content = interfaceController.getInterfaceContent(MOCK_SNAP_ID, id);
const state = interfaceController.getInterfaceState(MOCK_SNAP_ID, id);

const interfaceController = new InterfaceController({
messenger: controllerMessenger,
});
expect(content).toStrictEqual(newContent);
expect(state).toStrictEqual({ foo: { baz: null } });

await expect(
interfaceController.resolveInterface(MOCK_SNAP_ID, 'foo', null),
).rejects.toThrow("Interface with id 'foo' not found.");
expect(result).toBeNull();
});

it('throws if the interface is updated by another snap', async () => {
it('throws if the interface does not exist', () => {
const rootMessenger = getRootInterfaceControllerMessenger();
const controllerMessenger = getRestrictedInterfaceControllerMessenger(
rootMessenger,
Expand All @@ -199,16 +152,12 @@ describe('InterfaceController', () => {

const content = form({ name: 'foo', children: [input({ name: 'bar' })] });

const id = interfaceController.showInterface(MOCK_SNAP_ID, content);

await expect(
interfaceController.resolveInterface('foo', id, null),
).rejects.toThrow('Interface not created by foo.');
expect(() =>
interfaceController.updateInterface(MOCK_SNAP_ID, 'foo', content),
).toThrow("Interface with id 'foo' not found.");
});
});

describe('readInterface', () => {
it('gets the interface promise', () => {
it('throws if the interface is updated by another snap', () => {
const rootMessenger = getRootInterfaceControllerMessenger();
const controllerMessenger = getRestrictedInterfaceControllerMessenger(
rootMessenger,
Expand All @@ -221,14 +170,21 @@ describe('InterfaceController', () => {

const content = form({ name: 'foo', children: [input({ name: 'bar' })] });

const id = interfaceController.showInterface(MOCK_SNAP_ID, content);
const newContent = form({
name: 'foo',
children: [input({ name: 'baz' })],
});

const result = interfaceController.readInterface(MOCK_SNAP_ID, id);
const id = interfaceController.createInterface(MOCK_SNAP_ID, content);

expect(result).toBeInstanceOf(Promise);
expect(() =>
interfaceController.updateInterface('foo', id, newContent),
).toThrow('Interface not created by foo.');
});
});

it('throws if the interface does not exist', async () => {
describe('updateInterfaceState', () => {
it('updates the interface state', () => {
const rootMessenger = getRootInterfaceControllerMessenger();
const controllerMessenger = getRestrictedInterfaceControllerMessenger(
rootMessenger,
Expand All @@ -239,34 +195,22 @@ describe('InterfaceController', () => {
messenger: controllerMessenger,
});

await expect(
interfaceController.readInterface(MOCK_SNAP_ID, 'foo'),
).rejects.toThrow("Interface with id 'foo' not found.");
});
const content = form({ name: 'foo', children: [input({ name: 'bar' })] });

it('throws if the interface is updated by another snap', async () => {
const rootMessenger = getRootInterfaceControllerMessenger();
const controllerMessenger = getRestrictedInterfaceControllerMessenger(
rootMessenger,
true,
);
const newState = { foo: { bar: 'baz' } };

const interfaceController = new InterfaceController({
messenger: controllerMessenger,
});
const id = interfaceController.createInterface(MOCK_SNAP_ID, content);

const content = form({ name: 'foo', children: [input({ name: 'bar' })] });
interfaceController.updateInterfaceState(id, newState);

const id = interfaceController.showInterface(MOCK_SNAP_ID, content);
const result = interfaceController.getInterfaceState(MOCK_SNAP_ID, id);

await expect(
interfaceController.readInterface('foo', id),
).rejects.toThrow('Interface not created by foo.');
expect(result).toStrictEqual(newState);
});
});

describe('updateInterfaceState', () => {
it('updates the interface state', () => {
describe('deleteInterface', () => {
it('can delete an interface', () => {
const rootMessenger = getRootInterfaceControllerMessenger();
const controllerMessenger = getRestrictedInterfaceControllerMessenger(
rootMessenger,
Expand All @@ -279,15 +223,13 @@ describe('InterfaceController', () => {

const content = form({ name: 'foo', children: [input({ name: 'bar' })] });

const newState = { foo: { bar: 'baz' } };
const id = interfaceController.createInterface(MOCK_SNAP_ID, content);

const id = interfaceController.showInterface(MOCK_SNAP_ID, content);
interfaceController.deleteInterface(id);

interfaceController.updateInterfaceState(id, newState);

const result = interfaceController.getInterfaceState(MOCK_SNAP_ID, id);

expect(result).toStrictEqual(newState);
expect(() =>
interfaceController.getInterfaceContent(MOCK_SNAP_ID, id),
).toThrow(`Interface with id '${id}' not found.`);
});
});

Expand All @@ -305,7 +247,7 @@ describe('InterfaceController', () => {

const content = form({ name: 'foo', children: [input({ name: 'bar' })] });

const id = interfaceController.showInterface(MOCK_SNAP_ID, content);
const id = interfaceController.createInterface(MOCK_SNAP_ID, content);

const result = interfaceController.getInterfaceState(MOCK_SNAP_ID, id);

Expand Down Expand Up @@ -341,7 +283,7 @@ describe('InterfaceController', () => {

const content = form({ name: 'foo', children: [input({ name: 'bar' })] });

const id = interfaceController.showInterface(MOCK_SNAP_ID, content);
const id = interfaceController.createInterface(MOCK_SNAP_ID, content);

expect(() => interfaceController.getInterfaceState('foo', id)).toThrow(
'Interface not created by foo.',
Expand Down
Loading

0 comments on commit 490000b

Please sign in to comment.