TypeScript as-function.as-function函數代碼示例

async function checkOsXResult(packager: Packager, packagerOptions: PackagerOptions, checkOptions: AssertPackOptions, artifacts: Array<ArtifactCreated>) {
  const appInfo = packager.appInfo
  const packedAppDir = path.join(path.dirname(artifacts[0].file), `${appInfo.productFilename}.app`)
  const info = parsePlist(await readFile(path.join(packedAppDir, "Contents", "Info.plist"), "utf8"))
  assertThat2(info).has.properties({
    CFBundleDisplayName: appInfo.productName,
    CFBundleIdentifier: "org.electron-builder.testApp",
    LSApplicationCategoryType: "your.app.category.type",
    CFBundleVersion: `${appInfo.version}.${(process.env.TRAVIS_BUILD_NUMBER || process.env.CIRCLE_BUILD_NUM)}`
  })

  if (packagerOptions.cscLink != null) {
    const result = await exec("codesign", ["--verify", packedAppDir])
    assertThat2(result).not.match(/is not signed at all/)
  }

  const actualFiles = artifacts.map(it => path.basename(it.file)).sort()
  if (checkOptions != null && checkOptions.expectedContents != null) {
    assertThat(actualFiles).isEqualTo(checkOptions.expectedContents)
  }
  else {
    assertThat(actualFiles).isEqualTo([
      `${appInfo.productFilename}-${appInfo.version}-mac.zip`,
      `${appInfo.productFilename}-${appInfo.version}.dmg`,
    ].sort())

    assertThat(artifacts.map(it => it.artifactName).sort()).isEqualTo([
      `TestApp-${appInfo.version}-mac.zip`,
      `TestApp-${appInfo.version}.dmg`,
    ].sort())
  }
}

async function checkLinuxResult(projectDir: string, packager: Packager, packagerOptions: PackagerOptions) {
  const productName = getProductName(packager.metadata, packager.devMetadata)
  const expectedContents = expectedLinuxContents.map(it => {
    if (it === "/opt/TestApp/TestApp") {
      return "/opt/" + productName + "/" + productName
    }
    else if (it === "/usr/share/applications/TestApp.desktop") {
      return `/usr/share/applications/${productName}.desktop`
    }
    else {
      return it.replace(new RegExp("/opt/TestApp/", "g"), `/opt/${productName}/`)
    }
  })

  // console.log(JSON.stringify(await getContents(projectDir + "/dist/TestApp-1.0.0-amd64.deb", productName), null, 2))
  // console.log(JSON.stringify(await getContents(projectDir + "/dist/TestApp-1.0.0-i386.deb", productName), null, 2))

  const packageFile = `${projectDir}/${outDirName}/TestApp-1.1.0-amd64.deb`
  assertThat(await getContents(packageFile, productName)).deepEqual(expectedContents)
  if (packagerOptions.arch === "all" || packagerOptions.arch === "ia32") {
    assertThat(await getContents(`${projectDir}/${outDirName}/TestApp-1.1.0-i386.deb`, productName)).deepEqual(expectedContents)
  }

  assertThat(parseDebControl((await exec("dpkg", ["--info", packageFile])).toString())).has.properties({
    License: "MIT",
    Homepage: "http://foo.example.com",
    Maintainer: "Foo Bar <foo@example.com>",
    Vendor: "Foo Bar <foo@example.com>",
    Package: "testapp",
    Description: " \n   Test Application",
  })
}

async function checkOsXResult(packager: Packager, packagerOptions: PackagerOptions, checkOptions: AssertPackOptions, artifacts: Array<ArtifactCreated>) {
  const productName = getProductName(packager.metadata, packager.devMetadata)
  const packedAppDir = path.join(path.dirname(artifacts[0].file), (productName || packager.metadata.name) + ".app")
  const info = parsePlist(await readFile(path.join(packedAppDir, "Contents", "Info.plist"), "utf8"))
  assertThat(info).has.properties({
    CFBundleDisplayName: productName,
    CFBundleIdentifier: "your.id",
    LSApplicationCategoryType: "your.app.category.type",
    CFBundleVersion: "1.1.0" + "." + (process.env.TRAVIS_BUILD_NUMBER || process.env.CIRCLE_BUILD_NUM)
  })

  if (packagerOptions.csaLink != null) {
    const result = await exec("codesign", ["--verify", packedAppDir])
    assertThat(result[0].toString()).not.match(/is not signed at all/)
  }

  const actualFiles = artifacts.map(it => path.basename(it.file)).sort()
  if (checkOptions != null && checkOptions.expectedContents != null) {
    assertThat(actualFiles).deepEqual(checkOptions.expectedContents)
  }
  else {
    assertThat(actualFiles).deepEqual([
      `${productName}-1.1.0-mac.zip`,
      `${productName}-1.1.0.dmg`,
    ].sort())

    assertThat(artifacts.map(it => it.artifactName).sort()).deepEqual([
      "TestApp-1.1.0-mac.zip",
      "TestApp-1.1.0.dmg",
    ].sort())
  }
}

async function checkWindowsResult(packager: Packager, packagerOptions: PackagerOptions, artifacts: Array<ArtifactCreated>) {
  const productName = getProductName(packager.metadata, packager.devMetadata)

  function getWinExpected(archSuffix: string) {
    return [
      `RELEASES${archSuffix}`,
      `${productName}Setup-1.0.0${archSuffix}.exe`,
      `TestApp-1.0.0${archSuffix}-full.nupkg`,
    ]
  }

  const archSuffix = packagerOptions != null && packagerOptions.arch === "x64" ? "" : "-ia32"
  const expected = archSuffix == "" ? getWinExpected(archSuffix) : getWinExpected(archSuffix).concat(getWinExpected(""))

  const filenames = artifacts.map(it => path.basename(it.file))
  assertThat(filenames.slice().sort()).deepEqual(expected.slice().sort())

  let i = filenames.indexOf("RELEASES-ia32")
  if (i !== -1) {
    assertThat((await readText(artifacts[i].file)).indexOf("ia32")).not.equal(-1)
  }

  if (archSuffix == "") {
    const expectedArtifactNames = expected.slice()
    expectedArtifactNames[1] = `TestAppSetup-1.0.0${archSuffix}.exe`
    assertThat(artifacts.map(it => it.artifactName).filter(it => it != null)).deepEqual([`TestAppSetup-1.0.0${archSuffix}.exe`])
  }
}

async function packAndCheck(projectDir: string, platforms: string[], packagerOptions?: PackagerOptions) {
  const packager = new Packager(Object.assign({
    projectDir: projectDir,
    cscLink: CSC_LINK,
    cscKeyPassword: CSC_KEY_PASSWORD,
    dist: true,
    platform: platforms,
  }, packagerOptions))

  const artifacts: Map<Platform, Array<string>> = new Map()
  packager.artifactCreated((file, platform) => {
    let list = artifacts.get(platform)
    if (list == null) {
      list = []
      artifacts.set(platform, list)
    }
    list.push(file)
  })

  await packager.build()

  for (let key of artifacts.keys()) {
    artifacts.set(key, pathSorter(artifacts.get(key)))
  }

  const expandedPlatforms = normalizePlatforms(platforms)
  if (expandedPlatforms.includes("darwin")) {
    await checkOsXResult(packager, artifacts.get(Platform.OSX))
  }
  else if (expandedPlatforms.includes("linux")) {
    const productName = getProductName(packager.metadata)
    const expectedContents = expectedLinuxContents.map(it => {
      if (it === "/opt/TestApp/TestApp") {
        return "/opt/" + productName + "/" + productName
      }
      else if (it === "/usr/share/applications/TestApp.desktop") {
        return `/usr/share/applications/${productName}.desktop`
      }
      else {
        return it.replace(new RegExp("/opt/TestApp/", "g"), `/opt/${productName}/`)
      }
    })
    // let normalizedAppName = getProductName(packager.metadata).toLowerCase().replace(/ /g, '-')
    // expectedContents[expectedContents.indexOf("/usr/share/doc/testapp/")] = "/usr/share/doc/" + normalizedAppName + "/"
    // expectedContents[expectedContents.indexOf("/usr/share/doc/testapp/changelog.Debian.gz")] = "/usr/share/doc/" + normalizedAppName + "/changelog.Debian.gz"

    assertThat(await getContents(projectDir + "/dist/TestApp-1.0.0-amd64.deb", productName)).deepEqual(expectedContents)
    if (packagerOptions == null || packagerOptions.arch === null || packagerOptions.arch === "ia32") {
      assertThat(await getContents(projectDir + "/dist/TestApp-1.0.0-i386.deb", productName)).deepEqual(expectedContents)
    }
    // console.log(JSON.stringify(await getContents(projectDir + "/dist/TestApp-1.0.0-amd64.deb"), null, 2))
    // console.log(JSON.stringify(await getContents(projectDir + "/dist/TestApp-1.0.0-i386.deb"), null, 2))
  }
  else if (expandedPlatforms.includes("win32") && (packagerOptions == null || packagerOptions.target == null)) {
    await checkWindowsResult(packagerOptions, artifacts.get(Platform.WINDOWS))
  }
}

 packed: () => {
   assertThat(platformPackager.effectiveSignOptions).has.properties({
     identity: "osx",
     entitlements: "mas-entitlements file path",
     "entitlements-inherit": "mas-entitlementsInherit file path",
   })
   assertThat(platformPackager.effectiveFlatOptions).has.properties({
     identity: "MAS",
   })
   return BluebirdPromise.resolve(null)
 }

async function packAndCheck(projectDir: string, packagerOptions: PackagerOptions): Promise<void> {
  const packager = new Packager(packagerOptions)

  const artifacts: Map<Platform, Array<ArtifactCreated>> = new Map()
  packager.artifactCreated(event => {
    assertThat(path.isAbsolute(event.file)).true()
    let list = artifacts.get(event.platform)
    if (list == null) {
      list = []
      artifacts.set(event.platform, list)
    }
    list.push(event)
  })

  await packager.build()

  if (!packagerOptions.dist) {
    return
  }

  for (let platform of normalizePlatforms(packagerOptions.platform)) {
    if (platform === "darwin") {
      await checkOsXResult(packager, artifacts.get(Platform.OSX))
    }
    else if (platform === "linux") {
      const productName = getProductName(packager.metadata, packager.devMetadata)
      const expectedContents = expectedLinuxContents.map(it => {
        if (it === "/opt/TestApp/TestApp") {
          return "/opt/" + productName + "/" + productName
        }
        else if (it === "/usr/share/applications/TestApp.desktop") {
          return `/usr/share/applications/${productName}.desktop`
        }
        else {
          return it.replace(new RegExp("/opt/TestApp/", "g"), `/opt/${productName}/`)
        }
      })

      // console.log(JSON.stringify(await getContents(projectDir + "/dist/TestApp-1.0.0-amd64.deb", productName), null, 2))
      // console.log(JSON.stringify(await getContents(projectDir + "/dist/TestApp-1.0.0-i386.deb", productName), null, 2))

      assertThat(await getContents(projectDir + "/dist/TestApp-1.0.0-amd64.deb", productName)).deepEqual(expectedContents)
      if (packagerOptions == null || packagerOptions.arch === null || packagerOptions.arch === "ia32") {
        assertThat(await getContents(projectDir + "/dist/TestApp-1.0.0-i386.deb", productName)).deepEqual(expectedContents)
      }
    }
    else if (platform === "win32" && (packagerOptions == null || packagerOptions.target == null)) {
      await checkWindowsResult(packager, packagerOptions, artifacts.get(Platform.WINDOWS))
    }
  }
}

async function checkLinuxResult(projectDir: string, packager: Packager, packagerOptions: PackagerOptions, checkOptions: AssertPackOptions, artifacts: Array<ArtifactCreated>) {
  const customBuildOptions = packager.devMetadata.build.linux
  const targets = customBuildOptions == null || customBuildOptions.target == null ? ["default"] : customBuildOptions.target

  function getExpected(): Array<string> {
    const result: Array<string> = []
    for (let target of targets) {
      result.push(`TestApp-1.1.0.${target === "default" ? "deb" : target}`)
    }
    return result
  }

  assertThat(getFileNames(artifacts)).deepEqual((checkOptions == null || checkOptions.expectedArtifacts == null ? getExpected() : checkOptions.expectedArtifacts.slice()).sort())

  if (!targets.includes("deb") || !targets.includes("default")) {
    return
  }

  const productName = getProductName(packager.metadata, packager.devMetadata)
  const expectedContents = expectedLinuxContents.map(it => {
    if (it === "/opt/TestApp/TestApp") {
      return "/opt/" + productName + "/" + productName
    }
    else if (it === "/usr/share/applications/TestApp.desktop") {
      return `/usr/share/applications/${productName}.desktop`
    }
    else {
      return it.replace(new RegExp("/opt/TestApp/", "g"), `/opt/${productName}/`)
    }
  })

  // console.log(JSON.stringify(await getContents(projectDir + "/dist/TestApp-1.0.0-amd64.deb", productName), null, 2))
  // console.log(JSON.stringify(await getContents(projectDir + "/dist/TestApp-1.0.0-i386.deb", productName), null, 2))

  const packageFile = `${projectDir}/${outDirName}/TestApp-1.1.0-amd64.deb`
  assertThat(await getContents(packageFile, productName)).deepEqual(expectedContents)
  if (packagerOptions.arch === "all" || packagerOptions.arch === "ia32") {
    assertThat(await getContents(`${projectDir}/${outDirName}/TestApp-1.1.0-i386.deb`, productName)).deepEqual(expectedContents)
  }

  assertThat(parseDebControl(await exec("dpkg", ["--info", packageFile]))).has.properties({
    License: "MIT",
    Homepage: "http://foo.example.com",
    Maintainer: "Foo Bar <foo@example.com>",
    Vendor: "Foo Bar <foo@example.com>",
    Package: "testapp",
    Description: " \n   Test Application (test quite “ #378)",
    Depends: checkOptions == null || checkOptions.expectedDepends == null ? "libappindicator1, libnotify-bin" : checkOptions.expectedDepends,
  })
}

 packed: projectDir => {
   assertThat(platformPackager.effectiveSignOptions).has.properties({
     entitlements: path.join(projectDir, "build", "entitlements.osx.plist"),
     "entitlements-inherit": path.join(projectDir, "build", "entitlements.osx.inherit.plist"),
   })
   return BluebirdPromise.resolve(null)
 }

async function checkWindowsResult(packager: Packager, packagerOptions: PackagerOptions, checkOptions: AssertPackOptions, artifacts: Array<ArtifactCreated>) {
  const productName = getProductName(packager.metadata, packager.devMetadata)

  function getWinExpected(archSuffix: string) {
    return [
      `RELEASES${archSuffix}`,
      `${productName}Setup-1.0.0${archSuffix}.exe`,
      `TestApp-1.0.0${archSuffix}-full.nupkg`,
    ]
  }

  const archSuffix = (packagerOptions.arch || process.arch) === "x64" ? "" : "-ia32"
  const expected = archSuffix == "" ? getWinExpected(archSuffix) : getWinExpected(archSuffix).concat(getWinExpected(""))

  const filenames = artifacts.map(it => path.basename(it.file))
  assertThat(filenames.slice().sort()).deepEqual(expected.slice().sort())

  let i = filenames.indexOf("RELEASES-ia32")
  if (i !== -1) {
    assertThat((await readText(artifacts[i].file)).indexOf("ia32")).not.equal(-1)
  }

  if (archSuffix == "") {
    const expectedArtifactNames = expected.slice()
    expectedArtifactNames[1] = `TestAppSetup-1.0.0${archSuffix}.exe`
    assertThat(artifacts.map(it => it.artifactName).filter(it => it != null)).deepEqual([`TestAppSetup-1.0.0${archSuffix}.exe`])
  }

  const files = pathSorter((await new BluebirdPromise<Array<string>>((resolve, reject) => {
    const unZipper = new DecompressZip(path.join(path.dirname(artifacts[0].file), `TestApp-1.0.0${archSuffix}-full.nupkg`))
    unZipper.on("list", resolve)
    unZipper.on('error', reject)
    unZipper.list()
  })).map(it => it.replace(/\\/g, "/")).filter(it => (!it.startsWith("lib/net45/locales/") || it === "lib/net45/locales/en-US.pak") && !it.endsWith(".psmdcp")))

  // console.log(JSON.stringify(files, null, 2))
  const expectedContents = checkOptions == null || checkOptions.expectedContents == null ? expectedWinContents : checkOptions.expectedContents
  assertThat(files).deepEqual(expectedContents.map(it => {
    if (it === "lib/net45/TestApp.exe") {
      return `lib/net45/${productName.replace(/ /g, "%20")}.exe`
    }
    else {
      return it
    }
  }))
}