async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-electrode-bridge'),
        'nativeDeps'
      )
      const dependenciesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.nativeDeps'
      )[0]
      expect(dependenciesArr.includes('react-native-electrode-bridge@1.4.9'))
        .false
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-electrode-bridge'),
        'nativeDeps'
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('unexisting'),
          'nativeDeps'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'react-native-electrode-bridge',
          'nativeDeps'
        )
      )
    }


() => {
    it('should update the MiniApp version', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).updatePackageInContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-bar@3.0.0'),
        'miniApps'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniApps'
      )[0]
      expect(miniAppsArr.includes('react-native-bar@3.0.0')).true
      expect(miniAppsArr.includes('react-native-bar@2.0.0')).false
    })

    it('should commit the document store', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.updatePackageInContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-bar@3.0.0'),
        'miniApps'
      )
      sinon.assert.calledOnce(commitStub)
    })

    it('should throw if the miniapp is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-foo@3.0.0'),
          'miniApps'
        )
      )
    })

    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('react-native-bar@3.0.0'),
          'miniApps'
        )
      )
    })
  }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).updatePackageInContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-bar@3.0.0'),
        'miniApps'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniApps'
      )[0]
      expect(miniAppsArr.includes('react-native-bar@3.0.0')).true
      expect(miniAppsArr.includes('react-native-bar@2.0.0')).false
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.updatePackageInContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-bar@3.0.0'),
        'miniApps'
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-foo@3.0.0'),
          'miniApps'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('react-native-bar@3.0.0'),
          'miniApps'
        )
      )
    }


() => {
    it('should update the top level container version', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).updateTopLevelContainerVersion(
        AppPlatformDescriptor.fromString('test:android'),
        '2.0.0'
      )
      const topLevelContainerVersion = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].containerVersion'
      )[0]
      expect(topLevelContainerVersion).eql('2.0.0')
    })

    it('should commit the document store', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.updateTopLevelContainerVersion(
        AppPlatformDescriptor.fromString('test:android'),
        '2.0.0'
      )
      sinon.assert.calledOnce(commitStub)
    })
  }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).updateTopLevelContainerVersion(
        AppPlatformDescriptor.fromString('test:android'),
        '2.0.0'
      )
      const topLevelContainerVersion = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].containerVersion'
      )[0]
      expect(topLevelContainerVersion).eql('2.0.0')
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.updateTopLevelContainerVersion(
        AppPlatformDescriptor.fromString('test:android'),
        '2.0.0'
      )
      sinon.assert.calledOnce(commitStub)
    }


() => {
    it('should update the container version of the given native application version', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).updateContainerVersion(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        '2.0.0'
      )
      const nativeAppContainerVersion = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].containerVersion'
      )[0]
      expect(nativeAppContainerVersion).eql('2.0.0')
    })

    it('should commit the document store', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.updateContainerVersion(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        '2.0.0'
      )
      sinon.assert.calledOnce(commitStub)
    })

    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updateContainerVersion,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          '2.0.0'
        )
      )
    })
  }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).updateContainerVersion(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        '2.0.0'
      )
      const nativeAppContainerVersion = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].containerVersion'
      )[0]
      expect(nativeAppContainerVersion).eql('2.0.0')
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.updateContainerVersion(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        '2.0.0'
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updateContainerVersion,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          '2.0.0'
        )
      )
    }


() => {
    it('should return the top level container version', async () => {
      const result = await cauldronApi().getTopLevelContainerVersion(
        AppPlatformDescriptor.fromString('test:android')
      )
      expect(result).eql('1.16.44')
    })
  }


async () => {
      const result = await cauldronApi().getTopLevelContainerVersion(
        AppPlatformDescriptor.fromString('test:android')
      )
      expect(result).eql('1.16.44')
    }


() => {
    it('should return the container version of the given native application version', async () => {
      const result = await cauldronApi().getContainerVersion(
        AppVersionDescriptor.fromString('test:android:17.7.0')
      )
      expect(result).eql('1.16.44')
    })

    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.getContainerVersion,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0')
        )
      )
    })
  }


async () => {
      const result = await cauldronApi().getContainerVersion(
        AppVersionDescriptor.fromString('test:android:17.7.0')
      )
      expect(result).eql('1.16.44')
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.getContainerVersion,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0')
        )
      )
    }


() => {
    it('should remove the MiniApp from the container of the native application version', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-bar'),
        'miniApps'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniApps'
      )[0]
      expect(miniAppsArr.includes('react-native-bare@2.0.0')).false
    })

    it('should commit the document store', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-bar'),
        'miniApps'
      )
      sinon.assert.calledOnce(commitStub)
    })

    it('should throw if the MiniApp is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('unexisting'),
          'miniApps'
        )
      )
    })

    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('react-native-bar'),
          'miniApps'
        )
      )
    })
  }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-bar'),
        'miniApps'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniApps'
      )[0]
      expect(miniAppsArr.includes('react-native-bare@2.0.0')).false
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-bar'),
        'miniApps'
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('unexisting'),
          'miniApps'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('react-native-bar'),
          'miniApps'
        )
      )
    }


() => {
    it('should add the MiniApp to the container of the native application version', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('newMiniApp@1.0.0'),
        'miniApps'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniApps'
      )[0]
      expect(miniAppsArr.includes('newMiniApp@1.0.0')).true
    })

    it('should commit the document store', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('newMiniApp@1.0.0'),
        'miniApps'
      )
      sinon.assert.calledOnce(commitStub)
    })

    it('should throw if the MiniApp already exists', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-bar@2.0.0'),
          'miniApps'
        )
      )
    })

    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('newMiniApp@1.0.0'),
          'miniApps'
        )
      )
    })
  }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('newMiniApp@1.0.0'),
        'miniApps'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniApps'
      )[0]
      expect(miniAppsArr.includes('newMiniApp@1.0.0')).true
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('newMiniApp@1.0.0'),
        'miniApps'
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-bar@2.0.0'),
          'miniApps'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('newMiniApp@1.0.0'),
          'miniApps'
        )
      )
    }


() => {
    it('should add the native dependency to the container of the native application version', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('testDep@1.0.0'),
        'nativeDeps'
      )
      const dependenciesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.nativeDeps'
      )[0]
      expect(dependenciesArr.includes('testDep@1.0.0')).true
    })

    it('should commit the document store', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('testDep@1.0.0'),
        'nativeDeps'
      )
      sinon.assert.calledOnce(commitStub)
    })

    it('should throw if the dependency already exists', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-electrode-bridge@1.4.9'),
          'nativeDeps'
        )
      )
    })

    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('testDep@1.0.0'),
          'nativeDeps'
        )
      )
    })
  }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('testDep@1.0.0'),
        'nativeDeps'
      )
      const dependenciesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.nativeDeps'
      )[0]
      expect(dependenciesArr.includes('testDep@1.0.0')).true
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('testDep@1.0.0'),
        'nativeDeps'
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-electrode-bridge@1.4.9'),
          'nativeDeps'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('testDep@1.0.0'),
          'nativeDeps'
        )
      )
    }


() => {
    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('react-native-new-js-api-impl@1.0.0'),
          'jsApiImpls'
        )
      )
    })

    it('should throw if the js api impl already exists', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-my-api-impl@1.0.0'),
          'jsApiImpls'
        )
      )
    })

    it('should commit the document store', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-new-js-api-impl@1.0.0'),
        'jsApiImpls'
      )
      sinon.assert.calledOnce(commitStub)
    })

    it('should add the JS API impl to the container of the native application version', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-new-js-api-impl@1.0.0'),
        'jsApiImpls'
      )
      const dependenciesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImpls'
      )[0]
      expect(dependenciesArr.includes('react-native-new-js-api-impl@1.0.0'))
        .true
    })
  }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('react-native-new-js-api-impl@1.0.0'),
          'jsApiImpls'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-my-api-impl@1.0.0'),
          'jsApiImpls'
        )
      )
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-new-js-api-impl@1.0.0'),
        'jsApiImpls'
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-new-js-api-impl@1.0.0'),
        'jsApiImpls'
      )
      const dependenciesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImpls'
      )[0]
      expect(dependenciesArr.includes('react-native-new-js-api-impl@1.0.0'))
        .true
    }


() => {
    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('react-native-my-api-impl@1.0.0'),
          'jsApiImpls'
        )
      )
    })

    it('should throw if the js api impl is not found [1]', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-unknown-api-impl'),
          'jsApiImpls'
        )
      )
    })

    it('should throw if the js api impl is not found [2]', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-unknown-api-impl@1.0.0'),
          'jsApiImpls'
        )
      )
    })

    it('should commit the document store', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-my-api-impl@1.0.0'),
        'jsApiImpls'
      )
      sinon.assert.calledOnce(commitStub)
    })

    it('should remove the JS API impl from the container of the native application version [1]', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-my-api-impl'),
        'jsApiImpls'
      )
      const dependenciesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImpls'
      )[0]
      expect(dependenciesArr).not.includes('react-native-my-api-impl@1.0.0')
    })

    it('should remove the JS API impl from the container of the native application version [2]', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-my-api-impl@1.0.0'),
        'jsApiImpls'
      )
      const dependenciesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImpls'
      )[0]
      expect(dependenciesArr).not.includes('react-native-my-api-impl@1.0.0')
    })
  }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('react-native-my-api-impl@1.0.0'),
          'jsApiImpls'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-unknown-api-impl'),
          'jsApiImpls'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-unknown-api-impl@1.0.0'),
          'jsApiImpls'
        )
      )
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-my-api-impl@1.0.0'),
        'jsApiImpls'
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-my-api-impl'),
        'jsApiImpls'
      )
      const dependenciesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImpls'
      )[0]
      expect(dependenciesArr).not.includes('react-native-my-api-impl@1.0.0')
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-my-api-impl@1.0.0'),
        'jsApiImpls'
      )
      const dependenciesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImpls'
      )[0]
      expect(dependenciesArr).not.includes('react-native-my-api-impl@1.0.0')
    }


() => {
    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('react-native-my-api-impl@2.0.0'),
          'jsApiImpls'
        )
      )
    })

    it('should throw if the js api impl is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-unknown-api-impl@1.0.0'),
          'jsApiImpls'
        )
      )
    })

    it('should commit the document store', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.updatePackageInContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-my-api-impl@2.0.0'),
        'jsApiImpls'
      )
      sinon.assert.calledOnce(commitStub)
    })

    it('should update the JS API impl version', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).updatePackageInContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-my-api-impl@2.0.0'),
        'jsApiImpls'
      )
      const dependenciesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImpls'
      )[0]
      expect(dependenciesArr).includes('react-native-my-api-impl@2.0.0')
    })
  }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          PackagePath.fromString('react-native-my-api-impl@2.0.0'),
          'jsApiImpls'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('react-native-unknown-api-impl@1.0.0'),
          'jsApiImpls'
        )
      )
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.updatePackageInContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-my-api-impl@2.0.0'),
        'jsApiImpls'
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).updatePackageInContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('react-native-my-api-impl@2.0.0'),
        'jsApiImpls'
      )
      const dependenciesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImpls'
      )[0]
      expect(dependenciesArr).includes('react-native-my-api-impl@2.0.0')
    }


() => {
    it('should add the code push entry to QA', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).addCodePushEntry(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        codePushNewEntryFixture
      )
      const entries = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].codePush["QA"]'
      )[0]
      expect(entries)
        .to.be.an('array')
        .of.length(2)
    })

    it('should add the code push entry to new deployment name', async () => {
      const modifiedCodePushEntryFixture = Object.assign(
        {},
        codePushNewEntryFixture
      )
      modifiedCodePushEntryFixture.metadata.deploymentName = 'STAGING'
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).addCodePushEntry(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        modifiedCodePushEntryFixture
      )
      const entries = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].codePush["STAGING"]'
      )[0]
      expect(entries)
        .to.be.an('array')
        .of.length(1)
    })

    it('should commit the document store', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.addCodePushEntry(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        codePushNewEntryFixture
      )
      sinon.assert.calledOnce(commitStub)
    })

    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addCodePushEntry,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          codePushNewEntryFixture
        )
      )
    })
  }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).addCodePushEntry(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        codePushNewEntryFixture
      )
      const entries = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].codePush["QA"]'
      )[0]
      expect(entries)
        .to.be.an('array')
        .of.length(2)
    }


async () => {
      const modifiedCodePushEntryFixture = Object.assign(
        {},
        codePushNewEntryFixture
      )
      modifiedCodePushEntryFixture.metadata.deploymentName = 'STAGING'
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).addCodePushEntry(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        modifiedCodePushEntryFixture
      )
      const entries = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].codePush["STAGING"]'
      )[0]
      expect(entries)
        .to.be.an('array')
        .of.length(1)
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.addCodePushEntry(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        codePushNewEntryFixture
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addCodePushEntry,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          codePushNewEntryFixture
        )
      )
    }


() => {
    it('should throw if cauldronFilePath is undefined', async () => {
      const api = cauldronApi()
      assert(await doesThrow(api.addFile, api, { fileContent: 'content' }))
    })

    it('should throw if fileContent is undefined', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(api.addFile, api, { cauldronFilePath: 'dir/file' })
      )
    })

    it('should throw if file already exist', async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(
        await doesThrow(api.addFile, api, {
          cauldronFilePath: 'dir/file',
          fileContent: 'newcontent',
        })
      )
    })

    it('should not throw in nominal proper use case', async () => {
      const api = cauldronApi()
      assert(
        await doesNotThrow(api.addFile, api, {
          cauldronFilePath: 'dir/file',
          fileContent: 'content',
        })
      )
    })

    it('should add the file [non cauldron scheme]', async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(await api.hasFile({ cauldronFilePath: 'dir/file' }))
    })

    it('should add the file [cauldron scheme]', async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'cauldron://dir/file',
        fileContent: 'content',
      })
      assert(await api.hasFile({ cauldronFilePath: 'dir/file' }))
    })
  }


async () => {
      const api = cauldronApi()
      assert(await doesThrow(api.addFile, api, { fileContent: 'content' }))
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(api.addFile, api, { cauldronFilePath: 'dir/file' })
      )
    }


async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(
        await doesThrow(api.addFile, api, {
          cauldronFilePath: 'dir/file',
          fileContent: 'newcontent',
        })
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesNotThrow(api.addFile, api, {
          cauldronFilePath: 'dir/file',
          fileContent: 'content',
        })
      )
    }


async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(await api.hasFile({ cauldronFilePath: 'dir/file' }))
    }


async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'cauldron://dir/file',
        fileContent: 'content',
      })
      assert(await api.hasFile({ cauldronFilePath: 'dir/file' }))
    }


() => {
    it('should throw if cauldronFilePath is undefined', async () => {
      const api = cauldronApi()
      assert(await doesThrow(api.updateFile, api, { fileContent: 'content' }))
    })

    it('should throw if fileContent is undefined', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(api.updateFile, api, { cauldronFilePath: 'dir/file' })
      )
    })

    it('should throw if file does not already exist', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(api.updateFile, api, {
          cauldronFilePath: 'dir/file',
          fileContent: 'newcontent',
        })
      )
    })

    it('should not throw in nominal proper use case', async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(
        await doesNotThrow(api.updateFile, api, {
          cauldronFilePath: 'dir/file',
          fileContent: 'content',
        })
      )
    })

    it('should update the file [non cauldron scheme]', async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(
        await doesNotThrow(api.updateFile, api, {
          cauldronFilePath: 'dir/file',
          fileContent: 'content',
        })
      )
    })

    it('should update the file [cauldron scheme]', async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(
        await doesNotThrow(api.updateFile, api, {
          cauldronFilePath: 'cauldron://dir/file',
          fileContent: 'content',
        })
      )
    })
  }


async () => {
      const api = cauldronApi()
      assert(await doesThrow(api.updateFile, api, { fileContent: 'content' }))
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(api.updateFile, api, { cauldronFilePath: 'dir/file' })
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(api.updateFile, api, {
          cauldronFilePath: 'dir/file',
          fileContent: 'newcontent',
        })
      )
    }


async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(
        await doesNotThrow(api.updateFile, api, {
          cauldronFilePath: 'dir/file',
          fileContent: 'content',
        })
      )
    }


async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(
        await doesNotThrow(api.updateFile, api, {
          cauldronFilePath: 'cauldron://dir/file',
          fileContent: 'content',
        })
      )
    }


() => {
    it('should throw if cauldronFilePath is undefined', async () => {
      const api = cauldronApi()
      assert(await doesThrow(api.removeFile, api, {}))
    })

    it('should throw if file does not exist', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(api.removeFile, api, {
          cauldronFilePath: 'dir/file',
        })
      )
    })

    it('should not throw in nominal proper use case', async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(
        await doesNotThrow(api.removeFile, api, {
          cauldronFilePath: 'dir/file',
        })
      )
    })

    it('should remove the file [non cauldron scheme]', async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      await api.removeFile({
        cauldronFilePath: 'dir/file',
      })
      assert(!(await api.hasFile({ cauldronFilePath: 'dir/file' })))
    })

    it('should remove the file [cauldron scheme]', async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      await api.removeFile({
        cauldronFilePath: 'cauldron://dir/file',
      })
      assert(!(await api.hasFile({ cauldronFilePath: 'dir/file' })))
    })
  }


async () => {
      const api = cauldronApi()
      assert(await doesThrow(api.removeFile, api, {}))
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(api.removeFile, api, {
          cauldronFilePath: 'dir/file',
        })
      )
    }


async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(
        await doesNotThrow(api.removeFile, api, {
          cauldronFilePath: 'dir/file',
        })
      )
    }


async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      await api.removeFile({
        cauldronFilePath: 'dir/file',
      })
      assert(!(await api.hasFile({ cauldronFilePath: 'dir/file' })))
    }


async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      await api.removeFile({
        cauldronFilePath: 'cauldron://dir/file',
      })
      assert(!(await api.hasFile({ cauldronFilePath: 'dir/file' })))
    }


() => {
    it('should throw if cauldronFilePath is undefined', async () => {
      const api = cauldronApi()
      assert(await doesThrow(api.getFile, api, {}))
    })

    it('should throw if file does not exist', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(api.getFile, api, {
          cauldronFilePath: 'dir/file',
        })
      )
    })

    it('should not throw in nominal proper use case', async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(
        await doesNotThrow(api.getFile, api, {
          cauldronFilePath: 'dir/file',
        })
      )
    })

    it('should get the file [non cauldron scheme]', async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      const file = await api.getFile({ cauldronFilePath: 'dir/file' })
      expect(file.toString()).eql('content')
    })

    it('should get the file [cauldron scheme]', async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      const file = await api.getFile({
        cauldronFilePath: 'cauldron://dir/file',
      })
      expect(file.toString()).eql('content')
    })
  }


async () => {
      const api = cauldronApi()
      assert(await doesThrow(api.getFile, api, {}))
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(api.getFile, api, {
          cauldronFilePath: 'dir/file',
        })
      )
    }


async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      assert(
        await doesNotThrow(api.getFile, api, {
          cauldronFilePath: 'dir/file',
        })
      )
    }


async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      const file = await api.getFile({ cauldronFilePath: 'dir/file' })
      expect(file.toString()).eql('content')
    }


async () => {
      const api = cauldronApi()
      await api.addFile({
        cauldronFilePath: 'dir/file',
        fileContent: 'content',
      })
      const file = await api.getFile({
        cauldronFilePath: 'cauldron://dir/file',
      })
      expect(file.toString()).eql('content')
    }


() => {
    it('should return true if the native application version has the given yarn lock key', async () => {
      const hasYarnLock = await cauldronApi().hasYarnLock(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'Production'
      )
      expect(hasYarnLock).to.be.true
    })

    it('should return false if the native application version does not have the given yarn lock key', async () => {
      const hasYarnLock = await cauldronApi().hasYarnLock(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'Unexisting'
      )
      expect(hasYarnLock).to.be.false
    })

    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.hasYarnLock,
          api,
          'test',
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'Production'
        )
      )
    })
  }


async () => {
      const hasYarnLock = await cauldronApi().hasYarnLock(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'Production'
      )
      expect(hasYarnLock).to.be.true
    }


async () => {
      const hasYarnLock = await cauldronApi().hasYarnLock(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'Unexisting'
      )
      expect(hasYarnLock).to.be.false
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.hasYarnLock,
          api,
          'test',
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'Production'
        )
      )
    }


() => {
    it('should properly add the yarn lock', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).addYarnLock(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'YARN_LOCK_KEY',
        'YARN_LOCK_CONTENT'
      )
      const entry = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].yarnLocks["YARN_LOCK_KEY"]'
      )[0]
      expect(entry).not.undefined
    })

    it('should commit the document store', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.addYarnLock(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'YARN_LOCK_KEY',
        'YARN_LOCK_CONTENT'
      )
      sinon.assert.calledOnce(commitStub)
    })

    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addYarnLock,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'YARN_LOCK_KEY',
          'YARN_LOCK_CONTENT'
        )
      )
    })
  }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).addYarnLock(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'YARN_LOCK_KEY',
        'YARN_LOCK_CONTENT'
      )
      const entry = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].yarnLocks["YARN_LOCK_KEY"]'
      )[0]
      expect(entry).not.undefined
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.addYarnLock(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'YARN_LOCK_KEY',
        'YARN_LOCK_CONTENT'
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addYarnLock,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'YARN_LOCK_KEY',
          'YARN_LOCK_CONTENT'
        )
      )
    }


() => {
    it('should properly return the yarn lock id if it exists', async () => {
      const id = await cauldronApi().getYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'Production'
      )
      expect(id).eql('a0112c49-4bbc-47a9-ba45-d43e1e84a1a5')
    })

    it('should return undefined if the yarn lock key does not exists', async () => {
      const id = await cauldronApi().getYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'UnknownKey'
      )
      expect(id).undefined
    })

    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.getYarnLockId,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'Production'
        )
      )
    })
  }


async () => {
      const id = await cauldronApi().getYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'Production'
      )
      expect(id).eql('a0112c49-4bbc-47a9-ba45-d43e1e84a1a5')
    }


async () => {
      const id = await cauldronApi().getYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'UnknownKey'
      )
      expect(id).undefined
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.getYarnLockId,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'Production'
        )
      )
    }


() => {
    it('should properly set the yarn lock id of an existing key', async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).setYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'Production',
        newId
      )
      const entry = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].yarnLocks["Production"]'
      )[0]
      expect(entry).eql(newId)
    })

    it('should properly set the yarn lock id of an unexisting key', async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).setYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'NewKey',
        newId
      )
      const entry = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].yarnLocks["NewKey"]'
      )[0]
      expect(entry).eql(newId)
    })

    it('should commit the document store', async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.setYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'NewKey',
        newId
      )
      sinon.assert.calledOnce(commitStub)
    })

    it('should throw if the native application version is not found', async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.setYarnLockId,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'NewKey',
          newId
        )
      )
    })
  }


async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).setYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'Production',
        newId
      )
      const entry = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].yarnLocks["Production"]'
      )[0]
      expect(entry).eql(newId)
    }


async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).setYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'NewKey',
        newId
      )
      const entry = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].yarnLocks["NewKey"]'
      )[0]
      expect(entry).eql(newId)
    }


async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.setYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'NewKey',
        newId
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.setYarnLockId,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'NewKey',
          newId
        )
      )
    }


() => {
    it('should throw if the native application version is not found', async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.getYarnLock,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'Production'
        )
      )
    })
  }


async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.getYarnLock,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'Production'
        )
      )
    }


() => {
    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.getPathToYarnLock,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'Production'
        )
      )
    })
  }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.getPathToYarnLock,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'Production'
        )
      )
    }


() => {
    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removeYarnLock,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'Production'
        )
      )
    })
  }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.removeYarnLock,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'Production'
        )
      )
    }


() => {
    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updateYarnLock,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'Production',
          'NewLock'
        )
      )
    })
  }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updateYarnLock,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'Production',
          'NewLock'
        )
      )
    }


() => {
    it('should properly update the yarn lock id of an existing key', async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const api = cauldronApi()
      await api.updateYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'Production',
        newId
      )
      const id = await api.getYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'Production'
      )
      expect(id).eql(newId)
    })

    it('should properly set the yarn lock id of an unexisting key', async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const api = cauldronApi()
      await api.updateYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'NewKey',
        newId
      )
      const id = await api.getYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'NewKey'
      )
      expect(id).eql(newId)
    })

    it('should throw if the native application version is not found', async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updateYarnLockId,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'NewKey'
        )
      )
    })
  }


async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const api = cauldronApi()
      await api.updateYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'Production',
        newId
      )
      const id = await api.getYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'Production'
      )
      expect(id).eql(newId)
    }


async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const api = cauldronApi()
      await api.updateYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'NewKey',
        newId
      )
      const id = await api.getYarnLockId(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'NewKey'
      )
      expect(id).eql(newId)
    }


async () => {
      const newId = '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e'
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updateYarnLockId,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          'NewKey'
        )
      )
    }


() => {
    it('should set the yarn locks', async () => {
      const yarnLocks = { test: '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e' }
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).setYarnLocks(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        yarnLocks
      )
      const yarnLocksObj = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].yarnLocks'
      )[0]
      expect(yarnLocksObj).eql(yarnLocks)
    })

    it('should commit the document store', async () => {
      const yarnLocks = { test: '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e' }
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.setYarnLocks(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        yarnLocks
      )
      sinon.assert.calledOnce(commitStub)
    })

    it('should throw if the native application version is not found', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.setYarnLocks,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          { Test: '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e' }
        )
      )
    })
  }


async () => {
      const yarnLocks = { test: '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e' }
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).setYarnLocks(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        yarnLocks
      )
      const yarnLocksObj = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].yarnLocks'
      )[0]
      expect(yarnLocksObj).eql(yarnLocks)
    }


async () => {
      const yarnLocks = { test: '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e' }
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      const commitStub = sandbox.stub(documentStore, 'commit')
      await api.setYarnLocks(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        yarnLocks
      )
      sinon.assert.calledOnce(commitStub)
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.setYarnLocks,
          api,
          AppVersionDescriptor.fromString('test:android:17.20.0'),
          { Test: '30bf4eff61586d71fe5d52e31a2cfabcbb31e33e' }
        )
      )
    }


() => {
    it('should properly add the bundle', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).addBundle(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'BUNDLE_CONTENT'
      )
    })
  }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({ cauldronDocument: tmpFixture }).addBundle(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'BUNDLE_CONTENT'
      )
    }


() => {
    it('should return true if there is a stored bundle for the given native application descriptor', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await api.addBundle(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'BUNDLE_CONTENT'
      )
      assert(
        await api.hasBundle(
          AppVersionDescriptor.fromString('test:android:17.7.0')
        )
      )
    })

    it('should return false if there is no stored bundle for the given native application descriptor', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      assert(
        !(await api.hasBundle(
          AppVersionDescriptor.fromString('test:android:17.7.0')
        ))
      )
    })
  }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await api.addBundle(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'BUNDLE_CONTENT'
      )
      assert(
        await api.hasBundle(
          AppVersionDescriptor.fromString('test:android:17.7.0')
        )
      )
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      assert(
        !(await api.hasBundle(
          AppVersionDescriptor.fromString('test:android:17.7.0')
        ))
      )
    }


() => {
    it('should throw if the native application descriptor is partial', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.getBundle,
          api,
          AppPlatformDescriptor.fromString('test:android')
        )
      )
    })

    it('should throw if there is no stored bundle for the given native application descriptor', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      assert(
        await doesThrow(
          api.getBundle,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0')
        )
      )
    })

    it('should return the stored bundle for the given native application descriptor', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await api.addBundle(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'BUNDLE_CONTENT'
      )
      const result = await api.getBundle(
        AppVersionDescriptor.fromString('test:android:17.7.0')
      )
      expect(result.toString()).eql('BUNDLE_CONTENT')
    })
  }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.getBundle,
          api,
          AppPlatformDescriptor.fromString('test:android')
        )
      )
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      assert(
        await doesThrow(
          api.getBundle,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0')
        )
      )
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await api.addBundle(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        'BUNDLE_CONTENT'
      )
      const result = await api.getBundle(
        AppVersionDescriptor.fromString('test:android:17.7.0')
      )
      expect(result.toString()).eql('BUNDLE_CONTENT')
    }


() => {
    it('should throw if the native application descriptor is partial', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppPlatformDescriptor.fromString('test:android'),
          PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
          'miniAppsBranches'
        )
      )
    })

    it('should throw if the MiniApp path does not include a branch', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('https://github.com/foo/MiniApp.git'),
          'miniAppsBranches'
        )
      )
    })

    it('should add the MiniApp to the target container miniAppsBranches array', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniAppsBranches'
      )[0]
      expect(miniAppsArr.includes('https://github.com/foo/MiniApp.git#master'))
        .true
    })

    it('should throw if the MiniApp already has a branch specified', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString(
            'https://github.com/foo/MiniApp.git#development'
          ),
          'miniAppsBranches'
        )
      )
    })
  }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppPlatformDescriptor.fromString('test:android'),
          PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
          'miniAppsBranches'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('https://github.com/foo/MiniApp.git'),
          'miniAppsBranches'
        )
      )
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniAppsBranches'
      )[0]
      expect(miniAppsArr.includes('https://github.com/foo/MiniApp.git#master'))
        .true
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString(
            'https://github.com/foo/MiniApp.git#development'
          ),
          'miniAppsBranches'
        )
      )
    }


() => {
    it('should throw if the native application descriptor is partial', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppPlatformDescriptor.fromString('test:android'),
          PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
          'jsApiImplsBranches'
        )
      )
    })

    it('should throw if the JS API Impl path does not include a branch', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('https://github.com/foo/JsApiImpl.git'),
          'jsApiImplsBranches'
        )
      )
    })

    it('should add the JS API Impl to the target container jsApiImplsBranches array', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
        'jsApiImplsBranches'
      )
      const jsApiImplsBranchesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImplsBranches'
      )[0]
      expect(
        jsApiImplsBranchesArr.includes(
          'https://github.com/foo/JsApiImpl.git#master'
        )
      ).true
    })

    it('should throw if the JS API impl already has a branch specified', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
        'jsApiImplsBranches'
      )
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString(
            'https://github.com/foo/JsApiImpl.git#development'
          ),
          'jsApiImplsBranches'
        )
      )
    })
  }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppPlatformDescriptor.fromString('test:android'),
          PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
          'jsApiImplsBranches'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('https://github.com/foo/JsApiImpl.git'),
          'jsApiImplsBranches'
        )
      )
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
        'jsApiImplsBranches'
      )
      const jsApiImplsBranchesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImplsBranches'
      )[0]
      expect(
        jsApiImplsBranchesArr.includes(
          'https://github.com/foo/JsApiImpl.git#master'
        )
      ).true
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
        'jsApiImplsBranches'
      )
      assert(
        await doesThrow(
          api.addPackageToContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString(
            'https://github.com/foo/JsApiImpl.git#development'
          ),
          'jsApiImplsBranches'
        )
      )
    }


() => {
    it('should throw if the native application descriptor is partial', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppPlatformDescriptor.fromString('test:android'),
          PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
          'miniAppsBranches'
        )
      )
    })

    it('should throw if the MiniApp path does not include a branch', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('https://github.com/foo/MiniApp.git'),
          'miniAppsBranches'
        )
      )
    })

    it('should update the MiniApp branch in the target container miniAppsBranches array', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).updatePackageInContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString(
          'https://github.com/foo/MiniApp.git#development'
        ),
        'miniAppsBranches'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniAppsBranches'
      )[0]
      expect(
        miniAppsArr.includes('https://github.com/foo/MiniApp.git#development')
      ).true
    })
  }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppPlatformDescriptor.fromString('test:android'),
          PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
          'miniAppsBranches'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('https://github.com/foo/MiniApp.git'),
          'miniAppsBranches'
        )
      )
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).updatePackageInContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString(
          'https://github.com/foo/MiniApp.git#development'
        ),
        'miniAppsBranches'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniAppsBranches'
      )[0]
      expect(
        miniAppsArr.includes('https://github.com/foo/MiniApp.git#development')
      ).true
    }


() => {
    it('should throw if the native application descriptor is partial', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppPlatformDescriptor.fromString('test:android'),
          PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
          'jsApiImplsBranches'
        )
      )
    })

    it('should throw if the JS API Impl path does not include a branch', async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('https://github.com/foo/JsApiImpl.git'),
          'jsApiImplsBranches'
        )
      )
    })

    it('should update the JS API Impl branch in the target container jsApiImplsBranches array', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
        'jsApiImplsBranches'
      )
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).updatePackageInContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString(
          'https://github.com/foo/JsApiImpl.git#development'
        ),
        'jsApiImplsBranches'
      )
      const jsApiImplsBranchesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImplsBranches'
      )[0]
      expect(
        jsApiImplsBranchesArr.includes(
          'https://github.com/foo/JsApiImpl.git#development'
        )
      ).true
    })
  }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppPlatformDescriptor.fromString('test:android'),
          PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
          'jsApiImplsBranches'
        )
      )
    }


async () => {
      const api = cauldronApi()
      assert(
        await doesThrow(
          api.updatePackageInContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('https://github.com/foo/JsApiImpl.git'),
          'jsApiImplsBranches'
        )
      )
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
        'jsApiImplsBranches'
      )
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).updatePackageInContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString(
          'https://github.com/foo/JsApiImpl.git#development'
        ),
        'jsApiImplsBranches'
      )
      const jsApiImplsBranchesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImplsBranches'
      )[0]
      expect(
        jsApiImplsBranchesArr.includes(
          'https://github.com/foo/JsApiImpl.git#development'
        )
      ).true
    }


() => {
    it('should throw if the native application descriptor is partial', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppPlatformDescriptor.fromString('test:android'),
          PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
          'miniAppsBranches'
        )
      )
    })

    it('should throw if the MiniApp does not exist in the miniAppsBranches array', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('https://github.com/foo/foo.git'),
          'miniAppsBranches'
        )
      )
    })

    it('should remove the MiniApp branch from the target container miniAppsBranches array [branch specified]', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniAppsBranches'
      )[0]
      expect(miniAppsArr).empty
    })

    it('should remove the MiniApp branch from the target container miniAppsBranches array [branch not specified]', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git'),
        'miniAppsBranches'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniAppsBranches'
      )[0]
      expect(miniAppsArr).empty
    })
  }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppPlatformDescriptor.fromString('test:android'),
          PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
          'miniAppsBranches'
        )
      )
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('https://github.com/foo/foo.git'),
          'miniAppsBranches'
        )
      )
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniAppsBranches'
      )[0]
      expect(miniAppsArr).empty
    }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git#master'),
        'miniAppsBranches'
      )
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/MiniApp.git'),
        'miniAppsBranches'
      )
      const miniAppsArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.miniAppsBranches'
      )[0]
      expect(miniAppsArr).empty
    }


() => {
    it('should throw if the native application descriptor is partial', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
        'jsApiImplsBranches'
      )
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppPlatformDescriptor.fromString('test:android'),
          PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
          'jsApiImplsBranches'
        )
      )
    })

    it('should throw if the JS API Impl does not exist in the jsApiImplsBranches array', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
        'jsApiImplsBranches'
      )
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppVersionDescriptor.fromString('test:android:17.7.0'),
          PackagePath.fromString('https://github.com/foo/foo.git'),
          'jsApiImplsBranches'
        )
      )
    })

    it('should remove the JS API Impl branch from the target container jsApiImplsBranches array [branch specified]', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
        'jsApiImplsBranches'
      )
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
        'jsApiImplsBranches'
      )
      const jsApiImplBranchesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImplsBranches'
      )[0]
      expect(jsApiImplBranchesArr).empty
    })

    it('should remove the JS API Impl branch from the target container miniAppsBranches array [branch not specified]', async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
        'jsApiImplsBranches'
      )
      await cauldronApi({
        cauldronDocument: tmpFixture,
      }).removePackageFromContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git'),
        'jsApiImplsBranches'
      )
      const jsApiImplBranchesArr = jp.query(
        tmpFixture,
        '$.nativeApps[?(@.name=="test")].platforms[?(@.name=="android")].versions[?(@.name=="17.7.0")].container.jsApiImplsBranches'
      )[0]
      expect(jsApiImplBranchesArr).empty
    })
  }


async () => {
      const tmpFixture = JSON.parse(JSON.stringify(fixtures.defaultCauldron))
      const api = cauldronApi({ cauldronDocument: tmpFixture })
      await api.addPackageToContainer(
        AppVersionDescriptor.fromString('test:android:17.7.0'),
        PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
        'jsApiImplsBranches'
      )
      assert(
        await doesThrow(
          api.removePackageFromContainer,
          api,
          AppPlatformDescriptor.fromString('test:android'),
          PackagePath.fromString('https://github.com/foo/JsApiImpl.git#master'),
          'jsApiImplsBranches'
        )
      )
    }