Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Ryder/user-rpc tests #29

Merged
merged 3 commits into from
Feb 6, 2024
Merged

Ryder/user-rpc tests #29

Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
bacdb5b
Write initial basic User RPC tests
UZ9 Feb 3, 2024
6889b56
Add getUser test, starting code for invalid inputs
UZ9 Feb 4, 2024
49415c4
Refactor test file and add clarification comment
UZ9 Feb 6, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
274 changes: 174 additions & 100 deletions packages/db-service/test/app.e2e-spec.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,8 +11,7 @@ import {
UserProto,
UserProtoFile,
} from 'juno-proto';

// TODO: Make these actual tests
import { UserType } from 'juno-proto/dist/gen/user';

const { DBSERVICE_USER_PACKAGE_NAME } = UserProto;
const { DBSERVICE_PROJECT_PACKAGE_NAME } = ProjectProto;
Expand Down Expand Up @@ -53,24 +52,32 @@ afterEach(async () => {
});

describe('DB Service User Tests', () => {
let client: any;
let userClient: any;
let projectClient: any;

beforeEach(() => {
const proto = ProtoLoader.loadSync([
const userProto = ProtoLoader.loadSync([
UserProtoFile,
ProjectProtoFile,
IdentifiersProtoFile,
]) as any;

const protoGRPC = GRPC.loadPackageDefinition(proto) as any;
const userProtoGRPC = GRPC.loadPackageDefinition(userProto) as any;

userClient = new userProtoGRPC.dbservice.user.UserService(
process.env.DB_SERVICE_ADDR,
GRPC.credentials.createInsecure(),
);

client = new protoGRPC.dbservice.user.UserService(
projectClient = new userProtoGRPC.dbservice.project.ProjectService(
process.env.DB_SERVICE_ADDR,
GRPC.credentials.createInsecure(),
);
});

it('creates a new user', async () => {
const promise = new Promise((resolve) => {
client.createUser(
userClient.createUser(
{
email: 'test@test.com',
password: 'some-password',
Expand All @@ -90,105 +97,172 @@ describe('DB Service User Tests', () => {

await promise;
});
//
// it('updates a user', async () => {
// const promise = new Promise((resolve) => {
// client.revokeApiKey({}, (err, resp) => {
// expect(err).toBeNull();
// expect(resp).toStrictEqual({});
// resolve({});
// });
// });
//
// await promise;
// });
//
// it('gets a user', async () => {

it('can update the user with a valid id', async () => {
const promise = new Promise((resolve) => {
userClient.updateUser(
{
userIdentifier: { id: 1 },
updateParams: {
email: 'new@test.com',
name: 'new',
type: UserType.USER,
},
},
(err, resp) => {
expect(err).toBeNull();
expect(resp['email']).toBe('new@test.com');
expect(resp['name']).toBe('new');
expect(resp['type']).toBe(UserType.USER);
resolve({});
},
);
});

await promise;
});

it('can remove the user with a valid id', async () => {
const promise = new Promise((resolve) => {
userClient.deleteUser(
{
id: 1,
},
(err, resp) => {
expect(err).toBeNull();
expect(resp).toBeDefined();
resolve({});
},
);
});

await promise;
});

it('can link a valid user to a project', async () => {
const projectPromise = new Promise((resolve) => {
projectClient.createProject(
{
name: 'testproject',
},
(err, resp) => {
expect(err).toBeNull();
expect(resp['name']).toBe('testproject');
resolve({});
},
);
});

await projectPromise;

const promise = new Promise((resolve) => {
userClient.createUser(
{
email: 'test@test.com',
password: 'some-password',
name: 'some-name',
type: 'SUPERADMIN',
},
(err, resp) => {
expect(err).toBeNull();
expect(`${resp['id']}`).toBe('2');
expect(resp['email']).toBe('test@test.com');
expect(resp['name']).toBe('some-name');
expect(resp['type']).toBe(0);
resolve({});
},
);
});

await promise;

const promise1 = new Promise((resolve) => {
userClient.linkProject(
{
project: { name: 'testproject' },
user: { id: 2 },
},
(err, resp) => {
expect(err).toBeNull();
expect(resp['email']).toBe('test@test.com');
expect(resp['name']).toBe('some-name');
expect(resp['type']).toBe(UserType.SUPERADMIN);
resolve({});
},
);
});

await promise1;
});

it('can get a valid user', async () => {
const userPromise = new Promise((resolve) => {
userClient.createUser(
{
email: 'testvaliduser@test.com',
password: 'some-password',
name: 'some-name',
type: 'SUPERADMIN',
},
(err, resp) => {
expect(err).toBeNull();
expect(resp['email']).toBe('testvaliduser@test.com');
expect(resp['name']).toBe('some-name');
expect(resp['type']).toBe(0);
resolve({});
},
);
});

await userPromise;

const getUserPromise = new Promise((resolve) => {
userClient.getUser(
{
email: 'test@test.com',
},
(err, resp) => {
expect(err).toBeNull();
expect(resp).toBeDefined();
expect(resp['email']).toBe('test@test.com');
expect(resp['name']).toBe('some-name');
expect(resp['type']).toBe(0);
resolve({});
},
);
});

await getUserPromise;
});

// TODO: Wait for top level handler to manage invalid inputs
// it('throws an exception when updating the user with a invalid id', async () => {
// const promise = new Promise((resolve) => {
// client.revokeApiKey({}, (err, resp) => {
// expect(err).toBeNull();
// expect(resp).toStrictEqual({});
// resolve({});
// });
// userClient.updateUser(
// {
// userIdentifier: { id: 99999 },
// updateParams: { email: 'test@test.com' },
// },
// (err, resp) => {
// expect(err).toBeDefined();
// resolve({});
// },
// );
// }).catch((err) => {
// expect(err).toBeNull();
// });
//

// await promise;
// });
//
// it('deletes a user', async () => {
// const promise = new Promise((resolve) => {
// client.issueApiKey({}, (err, resp) => {
// expect(err).toBeNull();
// expect(resp).toStrictEqual({});
// it('throws an error when neither id nor email are provided', async () => {
// const getUserPromise = new Promise((resolve) => {
// userClient.getUser({}, (err, resp) => {
// expect(err).toBe('');
// resolve({});
// });
// });
//
// await promise;

// // Expect error, TODO: Find method of catching "Internal server error"
// expect(await getUserPromise).toThrow(Error);
// });
});

// describe('DB Service Project Tests', () => {
// let client: any;
// beforeEach(() => {
// const proto = ProtoLoader.loadSync([
// join(__dirname, '../../proto/db-service/project.proto'),
// join(__dirname, '../../proto/db-service/shared/identifiers.proto'),
// ]) as any;
//
// const protoGRPC = GRPC.loadPackageDefinition(proto) as any;
//
// client = new protoGRPC.dbservice.project.ProjectService(
// process.env.DB_SERVICE_ADDR,
// GRPC.credentials.createInsecure(),
// );
// });
//
// it('creates a new user', async () => {
// const promise = new Promise((resolve) => {
// client.issueApiKey({}, (err, resp) => {
// expect(err).toBeNull();
// expect(resp).toStrictEqual({});
// resolve({});
// });
// });
//
// await promise;
// });
//
// it('updates a user', async () => {
// const promise = new Promise((resolve) => {
// client.revokeApiKey({}, (err, resp) => {
// expect(err).toBeNull();
// expect(resp).toStrictEqual({});
// resolve({});
// });
// });
//
// await promise;
// });
//
// it('gets a user', async () => {
// const promise = new Promise((resolve) => {
// client.revokeApiKey({}, (err, resp) => {
// expect(err).toBeNull();
// expect(resp).toStrictEqual({});
// resolve({});
// });
// });
//
// await promise;
// });
//
// it('deletes a user', async () => {
// const promise = new Promise((resolve) => {
// client.issueApiKey({}, (err, resp) => {
// expect(err).toBeNull();
// expect(resp).toStrictEqual({});
// resolve({});
// });
// });
//
// await promise;
// });
// });
Loading