Page MenuHomeSealhub
Files F996072

D205.id.diff
No OneTemporary
Actions

D205.id.diff
View Options

diff --git a/lib/app/base-chips/field-types/field-types.test.js b/lib/app/base-chips/field-types/field-types.test.js
--- a/lib/app/base-chips/field-types/field-types.test.js
+++ b/lib/app/base-chips/field-types/field-types.test.js
@@ -1,3 +1,4 @@
describe("field types", () => {
require("./single_reference.subtest.js");
+ require("./text.subtest.js");
});
diff --git a/lib/app/base-chips/field-types/text.js b/lib/app/base-chips/field-types/text.js
--- a/lib/app/base-chips/field-types/text.js
+++ b/lib/app/base-chips/field-types/text.js
@@ -4,95 +4,119 @@
module.exports = {
name: "text",
- has_index: function(params){
- if(params.full_text_search || params.include_in_search){
- return {original: "text"};
- }else{
+ has_index: function(params) {
+ if (params.full_text_search || params.include_in_search) {
+ return { original: "text" };
+ } else {
return false;
}
},
- get_description: function(context, params){
+ get_description: function(context, params) {
return `Text with maximum length ${params.max_length}`;
},
- is_proper_value: function(context, params, new_value){
- const checks = [];
- if(params.min_length){
- checks.push((text) => {
- if(text.length < params.min_length){
- return Promise.reject(`Text '${new_value}' is too short, minimum length is ${params.min_length} chars.`);
+ is_proper_value: function(context, params, new_value) {
+ let checks = [];
+
+ checks.push(text => {
+ if (typeof new_value !== "string") {
+ return Promise.reject(
+ `Type of ${new_value} is ${typeof new_value}, not string.`
+ );
+ }
+ });
+ if (params.min_length) {
+ checks.push(text => {
+ if (text.length < params.min_length) {
+ return Promise.reject(
+ `Text '${new_value}' is too short, minimum length is ${
+ params.min_length
+ } chars.`
+ );
}
});
}
- if(params.max_length){
- checks.push((text) => {
- if(text.length > params.max_length){
- return Promise.reject(`Text '${new_value}' has exceeded max length of ${params.max_length} chars`);
+ if (params.max_length) {
+ checks.push(text => {
+ if (text.length > params.max_length) {
+ return Promise.reject(
+ `Text '${new_value}' has exceeded max length of ${
+ params.max_length
+ } chars.`
+ );
}
});
}
- return Promise.all(checks.map(fn => fn(new_value)))
- .then(() => Promise.resolve());
+ return Promise.all(checks.map(fn => fn(new_value))).then(() =>
+ Promise.resolve()
+ );
},
- encode: function(context, params, value_in_code){
- if (typeof value_in_code === "string" && value_in_code !== null){
+ encode: function(context, params, value_in_code) {
+ if (typeof value_in_code === "string" && value_in_code !== null) {
const result = {
- "original": value_in_code,
- "safe": escape(value_in_code),
- valueOf: function(){
+ original: value_in_code,
+ safe: escape(value_in_code),
+ valueOf: function() {
return value_in_code;
},
};
return Promise.resolve(result);
- } else {
- return Promise.resolve(null);
- }
+ } else return Promise.resolve(null);
},
- get_aggregation_stages: function(context, params, field_name, query_params){
- const filter_value = query_params.filter && query_params.filter[field_name];
- if(filter_value){
- if(filter_value.regex){
+ get_aggregation_stages: function(
+ context,
+ params,
+ field_name,
+ query_params
+ ) {
+ const filter_value =
+ query_params.filter && query_params.filter[field_name];
+ if (filter_value) {
+ if (filter_value.regex) {
const regex_options = "i";
- const regex_query = {$regex: filter_value.regex, $options: regex_options};
+ const regex_query = {
+ $regex: filter_value.regex,
+ $options: regex_options,
+ };
return [
{
$match: {
$or: [
{
- [`body.${ field_name }.original`]: regex_query,
+ [`body.${field_name}.original`]: regex_query,
},
{
- [`body.${ field_name }.safe`]: regex_query,
- }
- ]
+ [`body.${field_name}.safe`]: regex_query,
+ },
+ ],
},
},
];
- }else{
- const value_query = {$eq: filter_value};
+ } else {
+ const value_query = { $eq: filter_value };
return [
{
$match: {
$or: [
{
- [`body.${ field_name }.original`]: filter_value,
+ [`body.${field_name}.original`]: filter_value,
},
{
- [`body.${ field_name }.safe`]: filter_value,
- }
- ]
+ [`body.${field_name}.safe`]: filter_value,
+ },
+ ],
},
},
];
}
- }else{
+ } else {
return [];
}
},
- format: function(context, params, decoded_value, format){
- if(decoded_value === null || decoded_value === undefined){
+ format: function(context, params, decoded_value, format) {
+ if (decoded_value === null || decoded_value === undefined) {
return Promise.resolve(decoded_value);
}
- if(format === undefined){
+ if (format === undefined) {
return decoded_value.safe;
}
return decoded_value[format] ? decoded_value[format] : decoded_value;
diff --git a/lib/app/base-chips/field-types/text.subtest.js b/lib/app/base-chips/field-types/text.subtest.js
new file mode 100644
--- /dev/null
+++ b/lib/app/base-chips/field-types/text.subtest.js
@@ -0,0 +1,86 @@
+const assert = require("assert");
+const locreq = require("locreq")(__dirname);
+const axios = require("axios");
+const with_test_app = locreq("test_utils/with-test-app.js");
+
+describe("text", () => {
+ const COLLECTION_NAME = "surnames";
+
+ async function create_test_collection({ app, params }) {
+ app.createChip(app.Sealious.Collection, {
+ name: COLLECTION_NAME,
+ fields: [
+ {
+ name: "surname",
+ type: "text",
+ params,
+ },
+ ],
+ });
+ }
+
+ function assert_creation_error_factory({ base_url, collection }) {
+ return async ({ resource, message }) => {
+ try {
+ await axios.post(
+ `${base_url}/api/v1/collections/${collection}`,
+ resource
+ );
+ throw "This should not pass";
+ } catch (e) {
+ assert.deepEqual(e.response.data.data.surname.message, message);
+ }
+ };
+ }
+
+ it("shouldn't allow a value that isn't a string", async () =>
+ with_test_app(async ({ app, base_url }) => {
+ await create_test_collection({ app, params: {} });
+ const assert_creation_error = assert_creation_error_factory({
+ base_url,
+ collection: COLLECTION_NAME,
+ });
+ await assert_creation_error({
+ resource: { surname: false },
+ message: "Type of false is boolean, not string.",
+ });
+ await assert_creation_error({
+ resource: { surname: {} },
+ message: "Type of [object Object] is object, not string.",
+ });
+ }));
+
+ it("should respect given min and max length", async () =>
+ with_test_app(async ({ app, base_url }) => {
+ await create_test_collection({
+ app,
+ params: { min_length: 3, max_length: 5 },
+ });
+ const assert_creation_error = assert_creation_error_factory({
+ base_url,
+ collection: COLLECTION_NAME,
+ });
+ await assert_creation_error({
+ resource: { surname: "lo" },
+ message: "Text 'lo' is too short, minimum length is 3 chars.",
+ });
+ await assert_creation_error({
+ resource: { surname: "abcdefghijk" },
+ message:
+ "Text 'abcdefghijk' has exceeded max length of 5 chars.",
+ });
+ }));
+
+ it("should let proper string in", async () =>
+ with_test_app(async ({ app, base_url }) => {
+ await create_test_collection({
+ app,
+ params: { min_length: 3, max_length: 5 },
+ });
+ return axios
+ .post(`${base_url}/api/v1/collections/surnames`, {
+ surname: "1234",
+ })
+ .then(resp => assert.deepEqual(resp.status, 201));
+ }));
+});

File Metadata

Mime Type
text/plain
Expires
Mon, Dec 23, 09:05 (58 m, 18 s)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
557063
Default Alt Text
D205.id.diff (7 KB)

Event Timeline