test('File is downloaded from the redirect url', async () => {
     await DownloadFile(tmpFile.fd, fileDescription, eventStream, networkSettingsProvider, getURL(redirectUrlPath));
     const stats = await fs.stat(tmpFile.name);
     expect(stats.size).to.not.equal(0);
     let text = await fs.readFile(tmpFile.name, "utf8");
     expect(text).to.be.equal("Test content");
 });

 public async isPluginInstalled(): Promise<boolean> {
   let pluginDir = path.join(this._pluginsDirectory(), 'WakaTime');
   let stats = await fs.stat(pluginDir);
   return new Promise<boolean>(resolve => {
     resolve(stats.isDirectory());
   });
 }

 test('The folder is unzipped and the binaries have the expected permissions(except on Windows)', async () => {
     if (!((await PlatformInformation.GetCurrent()).isWindows())) {
         let resolvedBinaryPaths = Binaries.map(binary => path.join(installationPath, binary.path));
         await InstallZip(testBuffer, fileDescription, installationPath, resolvedBinaryPaths, eventStream);
         for (let binaryPath of resolvedBinaryPaths) {
             expect(await util.fileExists(binaryPath)).to.be.true;
             let mode = (await fs.stat(binaryPath)).mode;
             expect(mode & 0o7777).to.be.equal(0o755, `Expected mode for path ${binaryPath}`);
         }
     }
 });

async function uploadArchive(url: string, filePath: string) {
  const request = got.stream.put(url, {
    headers: {
      'content-length': (await fs.stat(filePath)).size
    }
  })

  fs.createReadStream(filePath).pipe(request)

  return new Promise((resolve: any, reject: any) => {
    request.on('error', reject)
    request.on('response', resolve)
  })
}

    public async compileContracts(): Promise<CompilerOutput> {
        // Check if all contracts are cached (and thus do not need to be compiled)
        try {
            const stats = await fs.stat(this.configuration.contractOutputPath);
            const lastCompiledTimestamp = stats.mtime;
            const ignoreCachedFile = function(file: string, stats: fs.Stats): boolean {
                return (stats.isFile() && path.extname(file) !== ".sol") || (stats.isFile() && path.extname(file) === ".sol" && stats.mtime < lastCompiledTimestamp);
            }
            const uncachedFiles = await recursiveReadDir(this.configuration.contractSourceRoot, [ignoreCachedFile]);
            if (uncachedFiles.length === 0) {
                return JSON.parse(await fs.readFile(this.configuration.contractOutputPath, "utf8"));
            }
        } catch {
            // Unable to read compiled contracts output file (likely because it has not been generated)
        }

        console.log('Compiling contracts, this may take a minute...');

        // Compile all contracts in the specified input directory
        const compilerInputJson = await this.generateCompilerInput();
        const compilerOutputJson = compileStandardWrapper(JSON.stringify(compilerInputJson));
        const compilerOutput: CompilerOutput = JSON.parse(compilerOutputJson);
        if (compilerOutput.errors) {
            let errors = "";

            for (let error of compilerOutput.errors) {
                // FIXME: https://github.com/ethereum/solidity/issues/3273
                if (error.message.includes("instruction is only available after the Metropolis hard fork")) continue;
                errors += error.formattedMessage + "\n";
            }

            if (errors.length > 0) {
                throw new Error("The following errors/warnings were returned by solc:\n\n" + errors);
            }
        }

        // Create output directory (if it doesn't exist)
        await asyncMkdirp(path.dirname(this.configuration.contractOutputPath));

        // Output contract data to single file
        const filteredCompilerOutput = this.filterCompilerOutput(compilerOutput);
        await fs.writeFile(this.configuration.contractOutputPath, JSON.stringify(filteredCompilerOutput, null, '\t'));

        // Output abi data to a single file
        const abiOutput = this.generateAbiOutput(filteredCompilerOutput);
        await fs.writeFile(this.configuration.abiOutputPath, JSON.stringify(abiOutput, null, '\t'));

        return filteredCompilerOutput;
    }

 public async isEditorInstalled(): Promise<boolean> {
   let stats = await fs.stat(this._appDirectory());
   return new Promise<boolean>(resolve => {
     resolve(stats.isDirectory());
   });
 }

 test(`Then it should not be empty`, async () => {
     const stats = await fs.stat(element);
     stats.size.should.be.greaterThan(0);
 });