110 lines
3.7 KiB
TypeScript
110 lines
3.7 KiB
TypeScript
import { TestBed } from '@angular/core/testing';
|
|
|
|
import { provideExperimentalZonelessChangeDetection } from '@angular/core';
|
|
import {
|
|
EnumMessage,
|
|
ListMessage,
|
|
MapMessage,
|
|
MessageTypeEnum,
|
|
ObjectMessage,
|
|
ProtoMessage,
|
|
} from './model/proto-message.model';
|
|
import { ProtoDefinitionService } from './proto-definition.service';
|
|
|
|
let testProto = `
|
|
syntax="proto3";
|
|
|
|
message Test {
|
|
message NestedMessage {
|
|
string nested = 1;
|
|
}
|
|
string hello = 1;
|
|
int32 hello2 = 2;
|
|
int64 hello3 = 3;
|
|
float hello4 = 4;
|
|
double hello5 = 5;
|
|
bool hello6 = 6;
|
|
repeated string hello7 = 7;
|
|
map<string, string> hello8 = 8;
|
|
ReferenceMessage hello9 = 9;
|
|
NestedMessage hello10 = 10;
|
|
EnumTest enum_test = 11;
|
|
}
|
|
|
|
message ReferenceMessage {
|
|
string test = 1;
|
|
}
|
|
|
|
enum EnumTest {
|
|
Hello = 0;
|
|
}
|
|
|
|
`;
|
|
|
|
describe('TestService', () => {
|
|
let service: ProtoDefinitionService;
|
|
|
|
beforeEach(() => {
|
|
TestBed.configureTestingModule({
|
|
providers: [provideExperimentalZonelessChangeDetection()],
|
|
});
|
|
service = TestBed.inject(ProtoDefinitionService);
|
|
});
|
|
|
|
it('should convert parse protobuf correctly', async () => {
|
|
const testMessages = await service.parseProtoDefinition(testProto);
|
|
const converted = testMessages[1];
|
|
|
|
expect(converted.name).toBe('Test');
|
|
|
|
expect(converted.values.length).toBe(11);
|
|
checkNameAndType(converted, 'hello', MessageTypeEnum.String);
|
|
checkNameAndType(converted, 'hello2', MessageTypeEnum.Numeric);
|
|
checkNameAndType(converted, 'hello3', MessageTypeEnum.Numeric);
|
|
checkNameAndType(converted, 'hello4', MessageTypeEnum.Numeric);
|
|
checkNameAndType(converted, 'hello5', MessageTypeEnum.Numeric);
|
|
checkNameAndType(converted, 'hello6', MessageTypeEnum.Boolean);
|
|
checkNameAndType(converted, 'hello7', MessageTypeEnum.List);
|
|
checkNameAndType(converted, 'hello8', MessageTypeEnum.Map);
|
|
checkNameAndType(converted, 'hello9', MessageTypeEnum.Object);
|
|
checkNameAndType(converted, 'hello10', MessageTypeEnum.Object);
|
|
checkNameAndType(converted, 'enumTest', MessageTypeEnum.Enum);
|
|
|
|
const listMessage = converted.values[6].configuration as ListMessage;
|
|
expect(listMessage.subConfiguration.type).toBe(MessageTypeEnum.String);
|
|
|
|
const mapMessage = converted.values[7].configuration as MapMessage;
|
|
expect(mapMessage.keyConfiguration.type).toBe(MessageTypeEnum.String);
|
|
expect(mapMessage.valueConfiguration.type).toBe(MessageTypeEnum.String);
|
|
|
|
const referenceMessage = converted.values[8].configuration as ObjectMessage;
|
|
expect(referenceMessage.messageDefinition.values.length).toBe(1);
|
|
expect(referenceMessage.messageDefinition.name).toBe('ReferenceMessage');
|
|
const nestedReferenceMessage = referenceMessage.messageDefinition.values[0];
|
|
expect(nestedReferenceMessage.configuration.type).toBe(
|
|
MessageTypeEnum.String
|
|
);
|
|
expect(nestedReferenceMessage.name).toBe('test');
|
|
|
|
const nestedMessage = converted.values[9].configuration as ObjectMessage;
|
|
expect(nestedMessage.messageDefinition.values.length).toBe(1);
|
|
expect(nestedMessage.messageDefinition.name).toBe('NestedMessage');
|
|
const nestedNestedMessage = nestedMessage.messageDefinition.values[0];
|
|
expect(nestedNestedMessage.configuration.type).toBe(MessageTypeEnum.String);
|
|
expect(nestedNestedMessage.name).toBe('nested');
|
|
|
|
const enumMessage = converted.values[10].configuration as EnumMessage;
|
|
expect(enumMessage.options.length).toBe(1);
|
|
expect(enumMessage.options[0]).toBe('Hello');
|
|
});
|
|
});
|
|
|
|
const checkNameAndType = (
|
|
converted: ProtoMessage,
|
|
name: string,
|
|
type: MessageTypeEnum
|
|
) => {
|
|
const field = converted.values.find((value) => value.name === name);
|
|
expect(field?.configuration.type).toBe(type);
|
|
};
|