751 lines
18 KiB
TypeScript
751 lines
18 KiB
TypeScript
/*
|
|
* Copyright 2025 coze-dev Authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import * as path from 'path';
|
|
|
|
import * as t from '../src/unify';
|
|
|
|
describe('unify-parser', () => {
|
|
describe('thrift index', () => {
|
|
it('should parse a simple file', () => {
|
|
const idl = path.resolve(__dirname, 'idl/index.thrift');
|
|
const expected = { uri_prefix: 'https://example.com' };
|
|
|
|
const document = t.parse(idl, { cache: false });
|
|
const { extensionConfig } = document.statements[0] as t.ServiceDefinition;
|
|
return expect(extensionConfig).to.eql(expected);
|
|
});
|
|
|
|
it('should parse a complicate file', () => {
|
|
const expected = {
|
|
namespace: 'unify_idx',
|
|
unifyNamespace: 'unify_idx',
|
|
include: ['./unify_dependent1.thrift', 'unify_dependent2.thrift'],
|
|
};
|
|
|
|
const document = t.parse('unify_index.thrift', {
|
|
root: path.resolve(__dirname, './idl'),
|
|
namespaceRefer: false,
|
|
cache: false,
|
|
});
|
|
const target = {
|
|
namespace: document.namespace,
|
|
unifyNamespace: document.unifyNamespace,
|
|
include: document.includes,
|
|
};
|
|
|
|
return expect(target).to.eql(expected);
|
|
});
|
|
|
|
it('should parse a complicate file with relative path', () => {
|
|
const expected = {
|
|
include: ['base.thrift', 'basee.thrift'],
|
|
};
|
|
|
|
const document = t.parse('dep/common.thrift', {
|
|
root: path.resolve(__dirname, './idl'),
|
|
namespaceRefer: false,
|
|
cache: false,
|
|
});
|
|
const target = {
|
|
include: document.includes,
|
|
};
|
|
|
|
return expect(target).to.eql(expected);
|
|
});
|
|
|
|
it('should parse files from fileContentMap', () => {
|
|
const indexContent = `
|
|
include './unify_dependent.thrift'
|
|
|
|
typedef unify_dependent.Foo TFoo
|
|
|
|
union FuncRequest {
|
|
1: unify_dependent.Foo r_key1
|
|
2: TFoo r_key2
|
|
}
|
|
|
|
service Example {
|
|
unify_dependent.FuncResponse Func(1: FuncRequest req)
|
|
} (
|
|
)
|
|
`;
|
|
const dependentContent = `
|
|
typedef Foo Foo1
|
|
|
|
struct Foo {
|
|
1: string f_key1
|
|
}
|
|
|
|
struct FuncResponse {
|
|
}
|
|
`;
|
|
const fileContentMap = {
|
|
'unify_index.thrift': indexContent,
|
|
'unify_dependent.thrift': dependentContent,
|
|
};
|
|
|
|
const expected = {
|
|
namespace: '',
|
|
unifyNamespace: 'root',
|
|
include: ['./unify_dependent.thrift'],
|
|
};
|
|
|
|
const document = t.parse(
|
|
'unify_index.thrift',
|
|
{ cache: false },
|
|
fileContentMap,
|
|
);
|
|
const target = {
|
|
namespace: document.namespace,
|
|
unifyNamespace: document.unifyNamespace,
|
|
include: document.includes,
|
|
};
|
|
|
|
return expect(target).to.eql(expected);
|
|
});
|
|
|
|
it('should parse files from fileContentMap with relative path', () => {
|
|
const indexContent = `
|
|
include 'unify_dependent.thrift'
|
|
|
|
typedef unify_dependent.Foo TFoo
|
|
|
|
union FuncRequest {
|
|
1: unify_dependent.Foo r_key1
|
|
2: TFoo r_key2
|
|
}
|
|
|
|
service Example {
|
|
unify_dependent.FuncResponse Func(1: FuncRequest req)
|
|
} (
|
|
)
|
|
`;
|
|
const dependentContent = `
|
|
typedef Foo Foo1
|
|
|
|
struct Foo {
|
|
1: string f_key1
|
|
}
|
|
|
|
struct FuncResponse {
|
|
}
|
|
`;
|
|
const fileContentMap = {
|
|
'relative/unify_index.thrift': indexContent,
|
|
'relative/unify_dependent.thrift': dependentContent,
|
|
};
|
|
|
|
const expected = {
|
|
namespace: '',
|
|
unifyNamespace: 'root',
|
|
include: ['unify_dependent.thrift'],
|
|
};
|
|
|
|
const document = t.parse(
|
|
'relative/unify_index.thrift',
|
|
{ cache: false },
|
|
fileContentMap,
|
|
);
|
|
const target = {
|
|
namespace: document.namespace,
|
|
unifyNamespace: document.unifyNamespace,
|
|
include: document.includes,
|
|
};
|
|
|
|
return expect(target).to.eql(expected);
|
|
});
|
|
|
|
it('should parse files from fileContentMap and Java namespace', () => {
|
|
const indexContent = `
|
|
namespace java com.ferry.index
|
|
|
|
union FuncRequest {
|
|
}
|
|
|
|
struct FuncResponse {}
|
|
|
|
service Example {
|
|
FuncResponse Func(1: FuncRequest req)
|
|
} (
|
|
)
|
|
`;
|
|
|
|
const fileContentMap = {
|
|
'unify_index.thrift': indexContent,
|
|
};
|
|
|
|
const expected = {
|
|
namespace: 'index',
|
|
unifyNamespace: 'index',
|
|
include: [],
|
|
};
|
|
|
|
const document = t.parse(
|
|
'unify_index.thrift',
|
|
{ cache: false },
|
|
fileContentMap,
|
|
);
|
|
const target = {
|
|
namespace: document.namespace,
|
|
unifyNamespace: document.unifyNamespace,
|
|
include: document.includes,
|
|
};
|
|
|
|
return expect(target).to.eql(expected);
|
|
});
|
|
|
|
it('should parse files with cache', () => {
|
|
const indexContent = `
|
|
struct Foo {}
|
|
`;
|
|
const indexxContent = `
|
|
`;
|
|
|
|
const rootContent = `
|
|
include "unify_index_cache.thrift"
|
|
`;
|
|
|
|
t.parse(
|
|
'unify_index_cache.thrift',
|
|
{
|
|
cache: true,
|
|
},
|
|
{
|
|
'unify_index_cache.thrift': indexContent,
|
|
},
|
|
);
|
|
|
|
t.parse(
|
|
'unify_root.thrift',
|
|
{ cache: false },
|
|
{
|
|
'unify_root.thrift': rootContent,
|
|
},
|
|
);
|
|
|
|
const document = t.parse(
|
|
'unify_index_cache.thrift',
|
|
{ cache: true },
|
|
{
|
|
'unify_index_cache.thrift': indexxContent,
|
|
},
|
|
);
|
|
|
|
return expect(document.statements[0].name.value).to.eql('Foo');
|
|
});
|
|
|
|
it('should parse files with ignoreTag', () => {
|
|
const indexContent = `
|
|
struct Foo {
|
|
1: string k1 (go.tag = "json:\\"key1\\"")
|
|
}
|
|
`;
|
|
|
|
const document = t.parse(
|
|
'unify_index.thrift',
|
|
{
|
|
ignoreGoTag: true,
|
|
},
|
|
{
|
|
'unify_index.thrift': indexContent,
|
|
},
|
|
);
|
|
const { fields } = document.statements[0] as t.InterfaceWithFields;
|
|
|
|
return expect(fields[0].extensionConfig).to.eql({});
|
|
});
|
|
|
|
it('should parse files with goTagDash', () => {
|
|
const indexContent = `
|
|
struct Foo {
|
|
1: string k1 (go.tag = "json:\\"-\\"")
|
|
}
|
|
`;
|
|
|
|
const document = t.parse(
|
|
'unify_index.thrift',
|
|
{},
|
|
{
|
|
'unify_index.thrift': indexContent,
|
|
},
|
|
);
|
|
const { fields } = document.statements[0] as t.InterfaceWithFields;
|
|
|
|
return expect(fields.length).to.eql(0);
|
|
});
|
|
|
|
it('should parse files with ignoreTagDash', () => {
|
|
const indexContent = `
|
|
struct Foo {
|
|
1: string k1 (go.tag = "json:\\"-\\"")
|
|
}
|
|
`;
|
|
|
|
const document = t.parse(
|
|
'unify_index.thrift',
|
|
{
|
|
ignoreGoTagDash: true,
|
|
},
|
|
{
|
|
'unify_index.thrift': indexContent,
|
|
},
|
|
);
|
|
const { fields } = document.statements[0] as t.InterfaceWithFields;
|
|
|
|
return expect(fields.length).to.eql(1);
|
|
});
|
|
|
|
it('should search files from searchPaths', () => {
|
|
const idl = path.resolve(__dirname, 'idl/unify_search.thrift');
|
|
const depDir = path.resolve(__dirname, 'idl/dep');
|
|
|
|
const document = t.parse(idl, {
|
|
cache: false,
|
|
searchPaths: [depDir],
|
|
});
|
|
|
|
const struct = document.statements[0] as t.InterfaceWithFields;
|
|
return expect(struct.type).to.eql(t.SyntaxType.StructDefinition);
|
|
});
|
|
|
|
it('should search files from relative searchPaths', () => {
|
|
const document = t.parse('unify_search.thrift', {
|
|
root: path.resolve(__dirname, 'idl'),
|
|
cache: false,
|
|
searchPaths: ['./dep'],
|
|
});
|
|
|
|
const struct = document.statements[0] as t.InterfaceWithFields;
|
|
return expect(struct.type).to.eql(t.SyntaxType.StructDefinition);
|
|
});
|
|
|
|
it('should parse files with a syntax error', () => {
|
|
const indexContent = `
|
|
struct
|
|
`;
|
|
|
|
try {
|
|
t.parse(
|
|
'error.thrift',
|
|
{ cache: false },
|
|
{
|
|
'error.thrift': indexContent,
|
|
},
|
|
);
|
|
} catch (err) {
|
|
return expect(err.message).to.eql(
|
|
'Struct-like must have an identifier',
|
|
);
|
|
}
|
|
|
|
return expect(0).to.eql(1);
|
|
});
|
|
|
|
it('should parse files with a dependent file error within fileContentMap', () => {
|
|
const indexContent = `
|
|
include "./dependent.thrift"
|
|
`;
|
|
|
|
try {
|
|
t.parse(
|
|
'error.thrift',
|
|
{ cache: false },
|
|
{
|
|
'error.thrift': indexContent,
|
|
},
|
|
);
|
|
} catch (err) {
|
|
return expect(err.message).to.eql(
|
|
'file dependent.thrift does not exist in fileContentMap',
|
|
);
|
|
}
|
|
|
|
return expect(0).to.eql(1);
|
|
});
|
|
|
|
it('should parse files with a entry file error within fileContentMap', () => {
|
|
try {
|
|
t.parse('specify_error.thrift', { cache: false }, {});
|
|
} catch (err) {
|
|
return expect(err.message).to.equal(
|
|
'file "specify_error.thrift" does not exist in fileContentMap',
|
|
);
|
|
}
|
|
|
|
return expect(0).to.eql(1);
|
|
});
|
|
|
|
it('should parse files with a entry file error', () => {
|
|
const idl = path.resolve(__dirname, 'idl/special_error.thrift');
|
|
|
|
try {
|
|
t.parse(idl, { cache: false });
|
|
} catch (err) {
|
|
return expect(err.message).to.contain('no such file:');
|
|
}
|
|
|
|
return expect(0).to.eql(1);
|
|
});
|
|
|
|
it('should parse files with a dependent file error', () => {
|
|
const idl = path.resolve(__dirname, 'idl/unify_error.thrift');
|
|
|
|
try {
|
|
t.parse(idl, { cache: false });
|
|
} catch (err) {
|
|
return expect(err.message).to.contain('does not exist');
|
|
}
|
|
|
|
return expect(0).to.eql(1);
|
|
});
|
|
|
|
it('should parse files with a namespace error', () => {
|
|
const indexContent = `
|
|
namespace java1 com.index
|
|
`;
|
|
|
|
try {
|
|
t.parse(
|
|
'error.thrift',
|
|
{ cache: false },
|
|
{
|
|
'error.thrift': indexContent,
|
|
},
|
|
);
|
|
} catch (err) {
|
|
return expect(err.message).to.eql('a js namespace should be specifed');
|
|
}
|
|
|
|
return expect(0).to.eql(1);
|
|
});
|
|
});
|
|
|
|
describe('proto index', () => {
|
|
it('should a simple file', () => {
|
|
const idl = path.resolve(__dirname, 'idl/index.proto');
|
|
const expected = { uri_prefix: '//example.com' };
|
|
const document = t.parse(idl, { cache: false });
|
|
const { extensionConfig } = document.statements[0] as t.ServiceDefinition;
|
|
return expect(extensionConfig).to.eql(expected);
|
|
});
|
|
|
|
it('should parse a complicate file', () => {
|
|
const expected = {
|
|
namespace: 'unify_idx',
|
|
unifyNamespace: 'unify_idx',
|
|
include: ['./unify_dependent1.proto', 'unify_dependent2.proto'],
|
|
};
|
|
|
|
const document = t.parse('unify_index.proto', {
|
|
root: path.resolve(__dirname, './idl'),
|
|
namespaceRefer: false,
|
|
cache: false,
|
|
});
|
|
const target = {
|
|
namespace: document.namespace,
|
|
unifyNamespace: document.unifyNamespace,
|
|
include: document.includes,
|
|
};
|
|
|
|
return expect(target).to.eql(expected);
|
|
});
|
|
|
|
it('should parse a complicate file with relative path', () => {
|
|
const expected = {
|
|
include: ['base.proto', 'basee.proto'],
|
|
};
|
|
|
|
const document = t.parse('dep/common.proto', {
|
|
root: path.resolve(__dirname, './idl'),
|
|
namespaceRefer: false,
|
|
cache: false,
|
|
});
|
|
const target = {
|
|
include: document.includes,
|
|
};
|
|
|
|
return expect(target).to.eql(expected);
|
|
});
|
|
|
|
it('should parse files from fileContentMap', () => {
|
|
const indexContent = `
|
|
syntax = "proto3";
|
|
import "./unify_dependent.proto";
|
|
|
|
message Request {
|
|
repeated string key1 = 1[(api.key) = 'f'];
|
|
unify_dep3.Foo key2 = 2;
|
|
}
|
|
|
|
service Example {
|
|
option (api.uri_prefix) = "//example.com";
|
|
rpc Biz1(Request) returns (unify_dep3.Response) {
|
|
option (api.uri) = '/api/biz1';
|
|
}
|
|
}
|
|
`;
|
|
const dependentContent = `
|
|
syntax = "proto3";
|
|
|
|
package unify_dep3;
|
|
|
|
message Foo {
|
|
string f_key1 = 1;
|
|
}
|
|
|
|
message Response {}
|
|
`;
|
|
const fileContentMap = {
|
|
'unify_index.proto': indexContent,
|
|
'unify_dependent.proto': dependentContent,
|
|
};
|
|
|
|
const expected = {
|
|
namespace: '',
|
|
unifyNamespace: 'root',
|
|
include: ['./unify_dependent.proto'],
|
|
};
|
|
|
|
const document = t.parse(
|
|
'unify_index.proto',
|
|
{ cache: false },
|
|
fileContentMap,
|
|
);
|
|
const target = {
|
|
namespace: document.namespace,
|
|
unifyNamespace: document.unifyNamespace,
|
|
include: document.includes,
|
|
};
|
|
|
|
return expect(target).to.eql(expected);
|
|
});
|
|
|
|
it('should parse files from fileContentMap with relative path', () => {
|
|
const indexContent = `
|
|
syntax = "proto3";
|
|
import "unify_dependent.proto";
|
|
|
|
message Request {
|
|
repeated string key1 = 1[(api.key) = 'f'];
|
|
unify_dep3.Foo key2 = 2;
|
|
}
|
|
|
|
service Example {
|
|
option (api.uri_prefix) = "//example.com";
|
|
rpc Biz1(Request) returns (unify_dep3.Response) {
|
|
option (api.uri) = '/api/biz1';
|
|
}
|
|
}
|
|
`;
|
|
const dependentContent = `
|
|
syntax = "proto3";
|
|
|
|
package unify_dep3;
|
|
|
|
message Foo {
|
|
string f_key1 = 1;
|
|
}
|
|
|
|
message Response {}
|
|
`;
|
|
const fileContentMap = {
|
|
'relative/unify_index.proto': indexContent,
|
|
'relative/unify_dependent.proto': dependentContent,
|
|
};
|
|
|
|
const expected = {
|
|
namespace: '',
|
|
unifyNamespace: 'root',
|
|
include: ['unify_dependent.proto'],
|
|
};
|
|
|
|
const document = t.parse(
|
|
'relative/unify_index.proto',
|
|
{ cache: false },
|
|
fileContentMap,
|
|
);
|
|
const target = {
|
|
namespace: document.namespace,
|
|
unifyNamespace: document.unifyNamespace,
|
|
include: document.includes,
|
|
};
|
|
|
|
return expect(target).to.eql(expected);
|
|
});
|
|
|
|
it('should parse files with cache', () => {
|
|
const indexContent = `
|
|
syntax = "proto3";
|
|
message Foo {}
|
|
`;
|
|
const indexxContent = `
|
|
syntax = "proto3";
|
|
`;
|
|
|
|
const rootContent = `
|
|
import "unify_index_cache.proto";
|
|
syntax = "proto3";
|
|
`;
|
|
|
|
t.parse(
|
|
'unify_index_cache.proto',
|
|
{
|
|
cache: true,
|
|
},
|
|
{
|
|
'unify_index_cache.proto': indexContent,
|
|
},
|
|
);
|
|
|
|
t.parse(
|
|
'unify_root.proto',
|
|
{ cache: false },
|
|
{
|
|
'unify_root.proto': rootContent,
|
|
},
|
|
);
|
|
|
|
const document = t.parse(
|
|
'unify_index_cache.proto',
|
|
{ cache: true },
|
|
{
|
|
'unify_index_cache.proto': indexxContent,
|
|
},
|
|
);
|
|
|
|
return expect(document.statements[0].name.value).to.eql('Foo');
|
|
});
|
|
|
|
it('should parse files ignoring import', () => {
|
|
const indexContent = `
|
|
syntax = "proto3";
|
|
import "google/protobuf/api.proto";
|
|
`;
|
|
|
|
t.parse(
|
|
'ignore.proto',
|
|
{ cache: false },
|
|
{
|
|
'ignore.proto': indexContent,
|
|
},
|
|
);
|
|
});
|
|
|
|
it('should search files from searchPaths', () => {
|
|
const idl = path.resolve(__dirname, 'idl/unify_search.proto');
|
|
const depDir = path.resolve(__dirname, 'idl/dep');
|
|
|
|
const document = t.parse(idl, {
|
|
cache: false,
|
|
searchPaths: [depDir],
|
|
});
|
|
|
|
const struct = document.statements[0] as t.InterfaceWithFields;
|
|
return expect(struct.type).to.eql(t.SyntaxType.StructDefinition);
|
|
});
|
|
|
|
it('should search files from relative searchPaths', () => {
|
|
const document = t.parse('unify_search.proto', {
|
|
root: path.resolve(__dirname, 'idl'),
|
|
cache: false,
|
|
searchPaths: ['./dep'],
|
|
});
|
|
|
|
const struct = document.statements[0] as t.InterfaceWithFields;
|
|
return expect(struct.type).to.eql(t.SyntaxType.StructDefinition);
|
|
});
|
|
|
|
it('should parse files with a syntax error', () => {
|
|
const indexContent = `
|
|
syntax = "proto3";
|
|
message Foo {
|
|
`;
|
|
|
|
try {
|
|
t.parse(
|
|
'error.proto',
|
|
{ cache: false },
|
|
{
|
|
'error.proto': indexContent,
|
|
},
|
|
);
|
|
} catch (err) {
|
|
return expect(err.message).to.eql("illegal token 'null', '=' expected");
|
|
}
|
|
|
|
return expect(0).to.eql(1);
|
|
});
|
|
|
|
it('should parse files with a entry file error within fileContentMap', () => {
|
|
try {
|
|
t.parse('specify_error.proto', { cache: false }, {});
|
|
} catch (err) {
|
|
return expect(err.message).to.equal(
|
|
'file "specify_error.proto" does not exist in fileContentMap',
|
|
);
|
|
}
|
|
|
|
return expect(0).to.eql(1);
|
|
});
|
|
|
|
it('should parse files with a file error', () => {
|
|
const indexContent = `
|
|
syntax = "proto3";
|
|
import "./dependent.proto";
|
|
`;
|
|
|
|
try {
|
|
t.parse(
|
|
'error.proto',
|
|
{ cache: false },
|
|
{
|
|
'error.proto': indexContent,
|
|
},
|
|
);
|
|
} catch (err) {
|
|
return expect(err.message).to.eql(
|
|
'file dependent.proto does not exist in fileContentMap',
|
|
);
|
|
}
|
|
|
|
return expect(0).to.eql(1);
|
|
});
|
|
|
|
it('should parse files with a real file error', () => {
|
|
try {
|
|
t.parse('real_error.proto', { cache: false });
|
|
} catch (err) {
|
|
return expect(err.message).to.contain('no such file');
|
|
}
|
|
|
|
return expect(0).to.eql(1);
|
|
});
|
|
});
|
|
|
|
describe('all index', () => {
|
|
it('should parse files with a file error', () => {
|
|
try {
|
|
t.parse('error', { cache: false });
|
|
} catch (err) {
|
|
return expect(err.message).to.eql('invalid filePath: "error"');
|
|
}
|
|
|
|
return expect(0).to.eql(1);
|
|
});
|
|
});
|
|
});
|