path: root/packages/sol-compiler/test/compiler_test.ts

import { join } from 'path';

import * as chai from 'chai';
import { CompilerOptions, ContractArtifact } from 'ethereum-types';
import 'mocha';

import { Compiler } from '../src/compiler';
import { fsWrapper } from '../src/utils/fs_wrapper';

import { exchange_binary } from './fixtures/exchange_bin';
import { chaiSetup } from './util/chai_setup';
import { constants } from './util/constants';

chaiSetup.configure();
const expect = chai.expect;

describe('#Compiler', function(): void {
    this.timeout(constants.timeoutMs); // tslint:disable-line:no-invalid-this
    const artifactsDir = `${__dirname}/fixtures/artifacts`;
    const contractsDir = `${__dirname}/fixtures/contracts`;
    const compilerOpts: CompilerOptions = {
        artifactsDir,
        contractsDir,
        contracts: constants.contracts,
    };
    it('should create an Exchange artifact with the correct unlinked binary', async () => {
        compilerOpts.contracts = ['Exchange'];

        const exchangeArtifactPath = `${artifactsDir}/Exchange.json`;
        if (fsWrapper.doesPathExistSync(exchangeArtifactPath)) {
            await fsWrapper.removeFileAsync(exchangeArtifactPath);
        }

        await new Compiler(compilerOpts).compileAsync();

        const opts = {
            encoding: 'utf8',
        };
        const exchangeArtifactString = await fsWrapper.readFileAsync(exchangeArtifactPath, opts);
        const exchangeArtifact: ContractArtifact = JSON.parse(exchangeArtifactString);
        // The last 43 bytes of the binaries are metadata which may not be equivalent
        const metadataByteLength = 43;
        const metadataHexLength = metadataByteLength * 2;
        const unlinkedBinaryWithoutMetadata = exchangeArtifact.compilerOutput.evm.bytecode.object.slice(
            2,
            -metadataHexLength,
        );
        const exchangeBinaryWithoutMetadata = exchange_binary.slice(0, -metadataHexLength);
        expect(unlinkedBinaryWithoutMetadata).to.equal(exchangeBinaryWithoutMetadata);
    });
    it("should throw when Whatever.sol doesn't contain a Whatever contract", async () => {
        const contract = 'BadContractName';

        const exchangeArtifactPath = `${artifactsDir}/${contract}.json`;
        if (fsWrapper.doesPathExistSync(exchangeArtifactPath)) {
            await fsWrapper.removeFileAsync(exchangeArtifactPath);
        }

        compilerOpts.contracts = [contract];
        const compiler = new Compiler(compilerOpts);

        expect(compiler.compileAsync()).to.be.rejected();
    });
    describe('after a successful compilation', () => {
        const contract = 'Exchange';
        let artifactPath: string;
        let artifactCreatedAtMs: number;
        beforeEach(async () => {
            compilerOpts.contracts = [contract];

            artifactPath = `${artifactsDir}/${contract}.json`;
            if (fsWrapper.doesPathExistSync(artifactPath)) {
                await fsWrapper.removeFileAsync(artifactPath);
            }

            await new Compiler(compilerOpts).compileAsync();

            artifactCreatedAtMs = (await fsWrapper.statAsync(artifactPath)).mtimeMs;
        });
        it('recompilation should update artifact when source has changed', async () => {
            // append some meaningless data to the contract, so that its hash
            // will change, so that the compiler will decide to recompile it.
            fsWrapper.appendFileAsync(join(contractsDir, `${contract}.sol`), ' ');

            await new Compiler(compilerOpts).compileAsync();

            const artifactModifiedAtMs = (await fsWrapper.statAsync(artifactPath)).mtimeMs;

            expect(artifactModifiedAtMs).to.be.greaterThan(artifactCreatedAtMs);
        });
        it("recompilation should NOT update artifact when source hasn't changed", async () => {
            await new Compiler(compilerOpts).compileAsync();

            const artifactModifiedAtMs = (await fsWrapper.statAsync(artifactPath)).mtimeMs;

            expect(artifactModifiedAtMs).to.equal(artifactCreatedAtMs);
        });
    });
    it('should only compile what was requested', async () => {
        // remove all artifacts
        for (const artifact of await fsWrapper.readdirAsync(artifactsDir)) {
            await fsWrapper.removeFileAsync(join(artifactsDir, artifact));
        }

        // compile EmptyContract
        compilerOpts.contracts = ['EmptyContract'];
        await new Compiler(compilerOpts).compileAsync();

        // make sure the artifacts dir only contains EmptyContract.json
        for (const artifact of await fsWrapper.readdirAsync(artifactsDir)) {
            expect(artifact).to.equal('EmptyContract.json');
        }
    });
});