improved test coverage

Author: harshithad0703

test/unit/asset-test.js

@@ -315,6 +315,67 @@ describe('Contentstack Asset test', () => {
       })
       .catch(done)
   })
+
+
+  it('Asset download test', done => {
+    var mock = new MockAdapter(Axios)
+    const downloadResponse = new Blob(['file content'], { type: 'text/plain' })
+
+    mock.onGet('/assets/download_url').reply(200, downloadResponse)
+
+    makeAsset({
+      asset: {
+        ...systemUidMock
+      },
+      stackHeaders: stackHeadersMock
+    })
+      .download({ url: '/assets/download_url', responseType: 'blob' })
+      .then((response) => {
+        expect(response.data).to.be.instanceOf(Blob)
+        expect(response.data.type).to.be.equal('text/plain')
+        done()
+      })
+      .catch(done)
+  })
+
+  it('Asset download test without url', done => {
+    var mock = new MockAdapter(Axios)
+    const downloadResponse = new Blob(['file content'], { type: 'text/plain' })
+
+    mock.onGet(`/assets/${systemUidMock.uid}`).reply(200, downloadResponse)
+
+    makeAsset({
+      asset: {
+        ...systemUidMock
+      },
+      stackHeaders: stackHeadersMock
+    })
+      .download({ responseType: 'blob' })
+      .then((response) => {
+        console.log("🚀 ~ .then ~ response:", response)
+        expect(response.data).to.be.instanceOf(Blob)
+        expect(response.data.type).to.be.equal('text/plain')
+        done()
+      })
+      .catch((err) => {
+        expect(err.message).to.be.equal('Asset URL can not be empty')
+        done()
+      })
+  })
+
+  it('Asset download test with missing url', done => {
+    makeAsset({
+      asset: {
+        ...systemUidMock
+      },
+      stackHeaders: stackHeadersMock
+    })
+      .download({ responseType: 'blob' })
+      .catch((err) => {
+        expect(err.message).to.be.equal('Asset URL can not be empty')
+        done()
+      })
+  })
 })
 
 function makeAsset (data) {

test/unit/contentType-test.js

@@ -280,6 +280,34 @@ describe('Contentstack ContentType test', () => {
         done()
       })
   })
+  it('should fetch references of a ContentType', done => {
+    var mock = new MockAdapter(Axios)
+    const referencesResponse = {
+      references: [
+        {
+          uid: 'entry_uid',
+          title: 'Entry Title',
+          content_type: 'UID'
+        }
+      ]
+    }
+    mock.onGet(`/content_types/UID/references`).reply(200, referencesResponse)
+    makeContentType({
+      content_type: {
+        ...systemUidMock
+      },
+      stackHeaders: stackHeadersMock
+    })
+      .references()
+      .then((response) => {
+        expect(response.references).to.be.an('array')
+        expect(response.references[0].uid).to.be.equal('entry_uid')
+        expect(response.references[0].title).to.be.equal('Entry Title')
+        expect(response.references[0].content_type).to.be.equal('UID')
+        done()
+      })
+      .catch(done)
+  })
 })
 
 function makeContentType (data) {

test/unit/entry-test.js

@@ -640,6 +640,37 @@ describe('Contentstack Entry test', () => {
       })
       .catch(done)
   })
+
+  it('should fetch variants of an Entry', done => {
+    var mock = new MockAdapter(Axios)
+    const variantsResponse = {
+      variants: [
+        {
+          uid: 'variant_uid',
+          title: 'Variant Title',
+          content_type: 'content_type_uid'
+        }
+      ]
+    }
+
+    mock.onGet(`/content_types/content_type_uid/entries/UID/variants/variantUid`).reply(200, variantsResponse)
+
+    makeEntry({
+      entry: {
+        ...systemUidMock
+      }
+    })
+      .variants('variantUid')
+      .fetch()
+      .then((response) => {
+        expect(response.variants).to.be.an('array')
+        expect(response.variants[0].uid).to.be.equal('variant_uid')
+        expect(response.variants[0].title).to.be.equal('Variant Title')
+        expect(response.variants[0].content_type).to.be.equal('content_type_uid')
+        done()
+      })
+      .catch(done)
+  })
 })
 
 function makeEntry (data) {

test/unit/globalField-test.js

@@ -438,6 +438,39 @@ describe("Contentstack GlobalField test (API Version 3.2)", () => {
       })
       .catch(done);
   });
+
+  it("should update nested global field", (done) => {
+    var mock = new MockAdapter(Axios);
+    const updatedData = {
+      global_field: {
+        title: "Updated Nested Global Field Title",
+        schema: nestedGlobalFieldPayload,
+      },
+    };
+
+    mock
+      .onPut(`/global_fields/${systemUidMock.uid}`)
+      .reply(200, {
+        global_field: {
+          ...nestedGlobalFieldMock,
+          ...updatedData.global_field,
+        },
+      });
+
+    makeGlobalField({
+      global_field: {
+        ...systemUidMock,
+      },
+      stackHeaders: stackHeadersMock,
+    })
+      .updateNestedGlobalField(updatedData)
+      .then((response) => {
+        expect(response.global_field.title).to.be.equal("Updated Nested Global Field Title");
+        expect(response.global_field.schema).to.deep.equal(nestedGlobalFieldPayload);
+        done();
+      })
+      .catch(done);
+  });
 });
 
 function makeGlobalField (data) {

test/unit/stack-test.js

@@ -2,7 +2,7 @@ import { describe, it } from 'mocha'
 import { Stack, StackCollection } from '../../lib/stack/index'
 import Axios from 'axios'
 import { expect } from 'chai'
-import { stackMock, noticeMock, systemUidMock } from './mock/objects'
+import { stackMock, noticeMock, systemUidMock, stackHeadersMock } from './mock/objects'
 import MockAdapter from 'axios-mock-adapter'
 
 describe('Contentstack Stack test', () => {
@@ -998,6 +998,93 @@ describe('Contentstack Stack test', () => {
       })
       .catch(done)
   })
+
+  it('Global fields initialization without uid', done => {
+    const global_field = makeStack({
+      stack: {
+        api_key: 'stack_api_key'
+      }
+    })
+    .globalField()
+    expect(global_field.uid).to.be.equal(undefined)
+    expect(global_field.stackHeaders).to.not.equal(undefined)
+    expect(global_field.stackHeaders.api_key).to.be.equal('stack_api_key')
+    done()
+  })
+
+  it('Management token initialization without uid', done => {
+    const management_token = makeStack({
+      stack: {
+        api_key: 'stack_api_key'
+      }
+    })
+    .managementToken()
+    expect(management_token.uid).to.be.equal(undefined)
+    expect(management_token.stackHeaders).to.not.equal(undefined)
+    expect(management_token.stackHeaders.api_key).to.be.equal('stack_api_key')
+    done()
+  })
+
+  it('Global fields initialization uid', done => {
+    const global_field = makeStack({
+      stack: {
+        api_key: 'stack_api_key'
+      }
+    })
+    .globalField(systemUidMock.uid)
+    expect(global_field.uid).to.be.equal(systemUidMock.uid)
+    expect(global_field.stackHeaders.api_key).to.be.equal('stack_api_key')
+    done()
+  })
+
+  it('Management token initialization uid', done => {
+    const management_token = makeStack({
+      stack: {
+        api_key: 'stack_api_key'
+      }
+    })
+    .managementToken(systemUidMock.uid)
+    expect(management_token.uid).to.be.equal(systemUidMock.uid)
+    expect(management_token.stackHeaders.api_key).to.be.equal('stack_api_key')
+    done()
+  })
+  
+  it('should update users roles', done => {
+    var mock = new MockAdapter(Axios)
+    const usersRolesData = {
+      user_uid: ['role_uid_1', 'role_uid_2']
+    }
+
+    mock.onPost('/stacks/users/roles').reply(200, {
+      notice: 'Roles updated successfully'
+    })
+
+    makeStack({
+      stack: {
+        api_key: 'stack_api_key'
+      }
+    })
+      .updateUsersRoles(usersRolesData)
+      .then((response) => {
+        expect(response.notice).to.be.equal('Roles updated successfully')
+        done()
+      })
+      .catch(done)
+  })
+
+  it('should fetch variants of a stack', done => {
+    var mock = new MockAdapter(Axios)
+    const variantsResponse = makeStack({
+      stack: {
+        api_key: 'stack_api_key'
+      }
+    })
+      .variants()
+      expect(variantsResponse.create).to.be.not.equal(undefined)
+      expect(variantsResponse.query).to.be.not.equal(undefined)
+      expect(variantsResponse.fetchByUIDs).to.be.not.equal(undefined)
+      done()
+  })
 })
 
 function makeStack (data) {

test/unit/variantGroup-test.js

@@ -152,6 +152,18 @@ describe('Contentstack VariantGroup test', () => {
       })
       .catch(done)
   })
+
+  it('should fetch variants of a VariantGroup', done => {
+    const variants = makeVariantGroup({
+      variant_group: {
+        ...systemUidMock
+      },
+      stackHeaders: stackHeadersMock
+    })
+    .variants()
+    expect(variants.variant_group_uid).to.be.equal(systemUidMock.uid)
+    done()
+  })
 })
 
 function makeVariantGroup (data = {}) {

test/unit/variants-entry-test.js

@@ -199,6 +199,46 @@ describe("Contentstack Variants entry test", () => {
       })
       .catch(done);
   });
+
+  it("Variants update test", (done) => {
+    var mock = new MockAdapter(Axios);
+    const updatedData = {
+      entry: {
+        title: "Updated Variant Title",
+        url: "/updated-variant-url",
+      },
+    };
+    const variantEntryMock = {
+      uid: 'variant_uid',
+      title: 'Variant Title',
+      content_type: 'content_type_uid',
+      locale: 'en-us',
+      _version: 1,
+      _in_progress: false
+    }
+
+    mock
+      .onPut(`/content_types/content_type_uid/entries/entry_uid/variants/variant_uid`)
+      .reply(200, {
+        entry: {
+          ...variantEntryMock,
+          ...updatedData.entry,
+        },
+      });
+
+      makeEntryVariants({
+      content_type_uid: "content_type_uid",
+      entry_uid: "entry_uid",
+      variants_uid: "variant_uid",
+    })
+      .update(updatedData)
+      .then((response) => {
+        expect(response.entry.title).to.be.equal("Updated Variant Title");
+        expect(response.entry.url).to.be.equal("/updated-variant-url");
+        done();
+      })
+      .catch(done);
+  });
 });
 
 function makeEntryVariants(data) {