@contentstack/datasync-mongodb-sdk 1.0.9-beta.1

package/test/comparison-operators.ts

@@ -0,0 +1,257 @@
+/**
+ * @description Test contentstack-mongodb-sdk basic methods
+ */
+
+import { cloneDeep } from 'lodash'
+import { Contentstack } from '../src'
+import { config } from './config'
+import { assets } from './data/assets'
+import { entries as authors } from './data/author'
+import { entries as blogs } from './data/blog'
+import { entries as categories } from './data/category'
+import { content_types } from './data/content_types'
+
+const scriptConfig = cloneDeep(config)
+const collNameConfig: any = scriptConfig.contentStore.collection
+collNameConfig.asset = 'contents.comparison_operators'
+collNameConfig.entry = 'contents.comparison_operators'
+collNameConfig.schema = 'content_types.comparison_operators'
+
+const Stack = Contentstack.Stack(scriptConfig)
+const collection = cloneDeep(collNameConfig)
+
+collection.asset = `en-us.${collNameConfig.asset}`
+collection.entry = `en-us.${collNameConfig.entry}`
+collection.schema = `en-us.${collNameConfig.schema}`
+
+let db
+
+const checkEntries = (result: any) => {
+  expect(result).toHaveProperty('entries')
+  expect(result).toHaveProperty('locale')
+  expect(result).toHaveProperty('content_type_uid')
+  expect(result.locale).toEqual('en-us')
+  expect(result.entries instanceof Array).toBeTruthy()
+  result.entries.forEach((item) => {
+    expect(item).not.toHaveProperty('_content_type_uid')
+  })
+}
+
+describe('# Comparison Operator Querying', () => {
+
+  beforeAll(() => {
+    return Stack.connect().then((dbInstance) => {
+      db = dbInstance
+
+      return
+    })
+  })
+
+  beforeAll(async () => {
+    await db.collection(collection.entry).insertMany(authors)
+    await db.collection(collection.entry).insertMany(blogs)
+    await db.collection(collection.entry).insertMany(categories)
+    await db.collection(collection.asset).insertMany(assets)
+    await db.collection(collection.schema).insertMany(content_types)
+
+    return
+  })
+
+  afterAll(async () => {
+    await db.collection(collection.entry).drop()
+    // await db.collection(collection.asset).drop()
+    await db.collection(collection.schema).drop()
+
+    return Stack.close()
+  })
+
+  describe('on: non pre-existing operator', () => {
+    test('.lessThan()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .lessThan('no', 1)
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+            expect(entry.no).toEqual(0)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.lessThanOrEqualTo()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .lessThanOrEqualTo('no', 0)
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+            expect(entry.no).toEqual(0)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.notEqualTo()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .notEqualTo('no', 0)
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(4)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+            expect(entry.no).not.toEqual(0)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.greaterThan()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .greaterThan('no', 5)
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+            expect(entry.no).toBeGreaterThan(5)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.greaterThanOrEqualTo()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .greaterThanOrEqualTo('no', 6)
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+            expect(entry.no).toBeGreaterThanOrEqual(6)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.containedIn()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .containedIn('tags', ['last'])
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('tags')
+            expect(entry.tags).toContain('last')
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.notContainedIn()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .notContainedIn('tags', ['last'])
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(4)
+          result.entries.forEach((entry) => {
+            if (entry.tags) {
+              expect(entry.tags).not.toContain('last')
+            }
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+
+  describe('on: pre-existing operator', () => {
+    test('.lessThan() + .lessThanOrEqualTo()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .lessThanOrEqualTo('no', 0)
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+            expect(entry.no).toEqual(0)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.notEqualTo() + .greaterThan() + .greaterThanOrEqualTo()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .notEqualTo('no', 0)
+        .greaterThan('no', 5)
+        .greaterThanOrEqualTo('no', 6)
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+            expect(entry.no).toBeGreaterThanOrEqual(6)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.containedIn() + .notContainedIn()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .containedIn('tags', ['last'])
+        .notContainedIn('tags', ['first'])
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(4)
+          result.entries.forEach((entry) => {
+            if (entry.tags) {
+              expect(entry.tags).not.toContain('first')
+            }
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+})
+

package/test/conditional-operators.ts

@@ -0,0 +1,106 @@
+/**
+ * @description Test contentstack-mongodb-sdk basic methods
+ */
+
+import { cloneDeep } from 'lodash'
+import { Contentstack } from '../src'
+import { config } from './config'
+import { assets } from './data/assets'
+import { entries as authors } from './data/author'
+import { entries as blogs } from './data/blog'
+import { entries as categories } from './data/category'
+import { content_types } from './data/content_types'
+
+const scriptConfig = cloneDeep(config)
+const collNameConfig: any = scriptConfig.contentStore.collection
+collNameConfig.asset = 'contents.conditional_operators'
+collNameConfig.entry = 'contents.conditional_operators'
+collNameConfig.schema = 'content_types.conditional_operators'
+
+const Stack = Contentstack.Stack(scriptConfig)
+const collection = cloneDeep(collNameConfig)
+
+collection.asset = `en-us.${collNameConfig.asset}`
+collection.entry = `en-us.${collNameConfig.entry}`
+collection.schema = `en-us.${collNameConfig.schema}`
+
+let db
+
+const checkEntries = (result: any) => {
+  expect(result).toHaveProperty('entries')
+  expect(result).toHaveProperty('locale')
+  expect(result).toHaveProperty('content_type_uid')
+  expect(result.locale).toEqual('en-us')
+  expect(result.entries instanceof Array).toBeTruthy()
+  result.entries.forEach((item) => {
+    expect(item).not.toHaveProperty('_content_type_uid')
+  })
+}
+
+describe('# Conditional Operators', () => {
+
+  beforeAll(() => {
+    return Stack.connect().then((dbInstance) => {
+      db = dbInstance
+
+      return
+    })
+  })
+
+  beforeAll(async () => {
+    await db.collection(collection.entry).insertMany(authors)
+    await db.collection(collection.entry).insertMany(blogs)
+    await db.collection(collection.entry).insertMany(categories)
+    await db.collection(collection.asset).insertMany(assets)
+    await db.collection(collection.schema).insertMany(content_types)
+
+    return
+  })
+
+  afterAll(async () => {
+    await db.collection(collection.entry).drop()
+    // await db.collection(collection.asset).drop()
+    await db.collection(collection.schema).drop()
+
+    return Stack.close()
+  })
+
+  describe('check key existence', () => {
+    test('.exists()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .exists('tags')
+        .exists('single_file')
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('tags')
+            expect(entry).toHaveProperty('single_file')
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.notExists()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .notExists('tags')
+        .notExists('single_file')
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          result.entries.forEach((entry) => {
+            expect(entry).not.toHaveProperty('tags')
+            expect(entry).not.toHaveProperty('single_file')
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+})
+

package/test/config.ts

@@ -0,0 +1,12 @@
+export const config = {
+  contentStore: {
+    collection: {
+      asset: 'contents',
+      entry: 'contents',
+      schema: 'content_types',
+    },
+    dbName: 'sync-test',
+    locale: 'en-us',
+    referenceDepth: 2,
+  },
+}

package/test/core.ts

@@ -0,0 +1,333 @@
+/**
+ * @description Test contentstack-mongodb-sdk basic methods
+ */
+
+import { cloneDeep } from 'lodash'
+import { Contentstack } from '../src'
+import { config } from './config'
+import { assets } from './data/assets'
+import { entries as authors } from './data/author'
+import { entries as blogs } from './data/blog'
+import { entries as categories } from './data/category'
+import { content_types } from './data/content_types'
+import { entries as products } from './data/products'
+
+const scriptConfig = cloneDeep(config)
+const collNameConfig: any = scriptConfig.contentStore.collection
+collNameConfig.asset = 'contents.core'
+collNameConfig.entry = 'contents.core'
+collNameConfig.schema = 'content_types.core'
+
+const Stack = Contentstack.Stack(scriptConfig)
+const collection = cloneDeep(collNameConfig)
+const collection2 = cloneDeep(collNameConfig)
+
+collection.asset = `en-us.${collNameConfig.asset}`
+collection.entry = `en-us.${collNameConfig.entry}`
+collection.schema = `en-us.${collNameConfig.schema}`
+
+collection2.asset = `es-es.${collNameConfig.asset}`
+collection2.entry = `es-es.${collNameConfig.entry}`
+collection2.schema = `es-es.${collNameConfig.schema}`
+
+let db
+
+const checkEntries = (result: any) => {
+  expect(result).toHaveProperty('entries')
+  expect(result).toHaveProperty('locale')
+  expect(result).toHaveProperty('content_type_uid')
+  expect(result.locale).toEqual('en-us')
+  expect(result.entries instanceof Array).toBeTruthy()
+  result.entries.forEach((item) => {
+    expect(item).not.toHaveProperty('_content_type_uid')
+  })
+}
+
+const checkAssets = (result: any) => {
+  expect(result).toHaveProperty('assets')
+  expect(result).toHaveProperty('locale')
+  expect(result).toHaveProperty('content_type_uid')
+  expect(result.content_type_uid).toEqual('assets')
+  expect(result.locale).toEqual('en-us')
+  expect(result.assets instanceof Array).toBeTruthy()
+  result.assets.forEach((item) => {
+    expect(item).not.toHaveProperty('_content_type_uid')
+  })
+}
+
+describe('# Core', () => {
+
+  beforeAll(() => {
+    return Stack.connect().then((dbInstance) => {
+      db = dbInstance
+
+      return
+    })
+  })
+
+  beforeAll(async () => {
+    await db.collection(collection.entry).insertMany(authors)
+    await db.collection(collection.entry).insertMany(blogs)
+    await db.collection(collection.entry).insertMany(categories)
+    await db.collection(collection.entry).insertMany(products)
+    await db.collection(collection.asset).insertMany(assets)
+    await db.collection(collection.schema).insertMany(content_types)
+
+    await db.collection(collection2.entry).insertMany(authors)
+    await db.collection(collection2.entry).insertMany(blogs)
+    await db.collection(collection2.entry).insertMany(products)
+    await db.collection(collection2.asset).insertMany(assets)
+    await db.collection(collection2.schema).insertMany(content_types)
+
+    return
+  })
+
+  afterAll(async () => {
+    await db.collection(collection.entry).drop()
+    // await db.collection(collection.asset).drop()
+    await db.collection(collection.schema).drop()
+
+    await db.collection(collection2.entry).drop()
+    // await db.collection(collection.asset).drop()
+    await db.collection(collection2.schema).drop()
+
+    return Stack.close()
+  })
+
+  test('initialize stack', () => {
+    expect(Contentstack.Stack())
+      .toHaveProperty('connect')
+  })
+
+  describe('entries', () => {
+    test('find', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(5)
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('find - language', () => {
+      return Stack.contentType('product')
+        .entries()
+        .language('es-es')
+        .find()
+        .then((result: any) => {
+          // checkEntries(result)
+          expect(result).toHaveProperty('entries')
+          expect(result).toHaveProperty('locale')
+          expect(result).toHaveProperty('content_type_uid')
+          expect(result.locale).toEqual('es-es')
+          expect(result.content_type_uid).toEqual('product')
+          expect(result.entries).toHaveLength(1)
+          expect(result.entries instanceof Array).toBeTruthy()
+          result.entries.forEach((item) => {
+            expect(item).not.toHaveProperty('_content_type_uid')
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('findOne', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .findOne()
+        .then((result: any) => {
+          expect(result).toHaveProperty('entry')
+          expect(result).toHaveProperty('content_type_uid')
+          expect(result).toHaveProperty('locale')
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.locale).toEqual('en-us')
+          expect(result.entry).toHaveProperty('title')
+          expect(result.entry).not.toHaveProperty('content_type_uid')
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('count', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .count()
+        .then((result: any) => {
+          expect(result).toHaveProperty('count')
+          expect(result).toHaveProperty('content_type_uid')
+          expect(result).toHaveProperty('locale')
+          expect(result.locale).toEqual('en-us')
+          expect(result.content_type_uid).toEqual('blog')
+          expect(Object.keys(result)).toHaveLength(3)
+          expect(result.count).toEqual(5)
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+
+  describe('assets', () => {
+    test('find', () => {
+      return Stack.assets()
+        .find()
+        .then((result: any) => {
+          checkAssets(result)
+          expect(result.assets).toHaveLength(3)
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('findOne', () => {
+      return Stack.assets()
+        .findOne()
+        .then((result: any) => {
+          expect(result).toHaveProperty('asset')
+          expect(result).toHaveProperty('content_type_uid')
+          expect(result).toHaveProperty('locale')
+          expect(result.content_type_uid).toEqual('assets')
+          expect(result.locale).toEqual('en-us')
+          expect(result.asset).toHaveProperty('title')
+          expect(result.asset).not.toHaveProperty('_content_type_uid')
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('count', () => {
+      return Stack.assets()
+        .count()
+        .then((result: any) => {
+          expect(result).toHaveProperty('count')
+          expect(result).toHaveProperty('content_type_uid')
+          expect(result).toHaveProperty('locale')
+          expect(result.locale).toEqual('en-us')
+          expect(result.content_type_uid).toEqual('assets')
+          expect(Object.keys(result)).toHaveLength(3)
+          expect(result.count).toEqual(3)
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+
+  describe('schemas', () => {
+    test('find', () => {
+      return Stack.schemas()
+        .find()
+        .then((result: any) => {
+          expect(result).toHaveProperty('locale')
+          expect(result.locale).toEqual('en-us')
+          expect(result).toHaveProperty('content_types')
+          expect(result.content_type_uid).toEqual('content_types')
+          expect(result.content_types instanceof Array).toBeTruthy()
+          expect(result.content_types).toHaveLength(4)
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('findOne', () => {
+      return Stack.schemas()
+        .findOne()
+        .then((result: any) => {
+          expect(result).toHaveProperty('content_type')
+          expect(result.content_type_uid).toEqual('content_types')
+          expect(result.content_type).toHaveProperty('title')
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('count', () => {
+      return Stack.schemas()
+        .count()
+        .then((result: any) => {
+          expect(result).toHaveProperty('count')
+          expect(result).toHaveProperty('content_type_uid')
+          expect(result).toHaveProperty('locale')
+          expect(result.locale).toEqual('en-us')
+          expect(result.content_type_uid).toEqual('content_types')
+          expect(Object.keys(result)).toHaveLength(3)
+          expect(result.count).toEqual(4)
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+
+  describe('entry', () => {
+    test('find', () => {
+      return Stack.contentType('blog')
+        .entry()
+        .find()
+        .then((result: any) => {
+          expect(result).toHaveProperty('entry')
+          expect(result).toHaveProperty('content_type_uid')
+          expect(result).toHaveProperty('locale')
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.locale).toEqual('en-us')
+          expect(result.entry).toHaveProperty('title')
+          expect(result.entry).not.toHaveProperty('content_type_uid')
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+
+  describe('asset', () => {
+    test('find', () => {
+      return Stack.asset()
+        .find()
+        .then((result: any) => {
+          expect(result).toHaveProperty('asset')
+          expect(result).toHaveProperty('content_type_uid')
+          expect(result).toHaveProperty('locale')
+          expect(result.content_type_uid).toEqual('assets')
+          expect(result.locale).toEqual('en-us')
+          expect(result.asset).toHaveProperty('title')
+          expect(result.asset).not.toHaveProperty('_content_type_uid')
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+
+  describe('schema', () => {
+    test('find', () => {
+      return Stack.schema()
+        .find()
+        .then((result: any) => {
+          expect(result).toHaveProperty('locale')
+          expect(result).toHaveProperty('content_type')
+          expect(result).toHaveProperty('content_type_uid')
+          expect(result.locale).toEqual('en-us')
+          expect(result.content_type_uid).toEqual('content_types')
+          expect(result.content_type).toHaveProperty('title')
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('count', () => {
+      return Stack.schemas()
+        .count()
+        .then((result: any) => {
+          expect(result).toHaveProperty('count')
+          expect(result).toHaveProperty('content_type_uid')
+          expect(result).toHaveProperty('locale')
+          expect(result.locale).toEqual('en-us')
+          expect(result.content_type_uid).toEqual('content_types')
+          expect(Object.keys(result)).toHaveLength(3)
+          expect(result.count).toEqual(4)
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+})
+