@graphprotocol/graph-cli 0.32.0 → 0.34.0-alpha.0

package/src/scaffold/ethereum.test.js

@@ -243,6 +243,265 @@ export function handleExampleEvent1(event: ExampleEvent1Event): void {
   entity.a = event.params.a
   entity.save()
 }
+`)
+  })
+
+  test('Test Files (default)', () => {
+    const files = scaffoldWithIndexEvents.generateTests()
+    const testFile = files['contract.test.ts']
+    const utilsFile = files['contract-utils.ts']
+    expect(testFile).toEqual(`\
+import {
+  assert,
+  describe,
+  test,
+  clearStore,
+  beforeAll,
+  afterAll
+} from \"matchstick-as/assembly/index\"
+import { BigInt, Bytes } from \"@graphprotocol/graph-ts\"
+import { ExampleEvent } from \"../generated/schema\"
+import { ExampleEvent as ExampleEventEvent } from \"../generated/Contract/Contract\"
+import { handleExampleEvent } from \"../src/contract\"
+import { createExampleEventEvent } from \"./contract-utils\"
+
+// Tests structure (matchstick-as >=0.5.0)
+// https://thegraph.com/docs/en/developer/matchstick/#tests-structure-0-5-0
+
+describe(\"Describe entity assertions\", () => {
+  beforeAll(() => {
+    let a = BigInt.fromI32(234)
+    let b = [Bytes.fromI32(1234567890)]
+    let param2 = \"Example string value\"
+    let c = \"ethereum.Tuple Not implemented\"
+    let d = \"Example string value\"
+    let newExampleEventEvent = createExampleEventEvent(a, b, param2, c, d)
+    handleExampleEvent(newExampleEventEvent)
+  })
+
+  afterAll(() => {
+    clearStore()
+  })
+
+  // For more test scenarios, see:
+  // https://thegraph.com/docs/en/developer/matchstick/#write-a-unit-test
+
+  test(\"ExampleEvent created and stored\", () => {
+    assert.entityCount(\"ExampleEvent\", 1)
+
+    // 0xa16081f360e3847006db660bae1c6d1b2e17ec2a is the default address used in newMockEvent() function
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"a\",
+      \"234\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"b\",
+      \"[1234567890]\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"param2\",
+      \"Example string value\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"c\",
+      \"ethereum.Tuple Not implemented\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"d\",
+      \"Example string value\"
+    )
+
+    // More assert options:
+    // https://thegraph.com/docs/en/developer/matchstick/#asserts
+  })
+})
+`)
+    expect(utilsFile).toEqual(`\
+import { newMockEvent } from \"matchstick-as\"
+import { ethereum, BigInt, Bytes } from \"@graphprotocol/graph-ts\"
+import { ExampleEvent, ExampleEvent1 } from \"../generated/Contract/Contract\"
+
+export function createExampleEventEvent(
+  a: BigInt,
+  b: Array<Bytes>,
+  param2: string,
+  c: ethereum.Tuple,
+  d: string
+): ExampleEvent {
+  let exampleEventEvent = changetype<ExampleEvent>(newMockEvent())
+
+  exampleEventEvent.parameters = new Array()
+
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"a\", ethereum.Value.fromUnsignedBigInt(a))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"b\", ethereum.Value.fromBytesArray(b))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"param2\", ethereum.Value.fromString(param2))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"c\", ethereum.Value.fromTuple(c))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"d\", ethereum.Value.fromString(d))
+  )
+
+  return exampleEventEvent
+}
+
+export function createExampleEvent1Event(a: Bytes): ExampleEvent1 {
+  let exampleEvent1Event = changetype<ExampleEvent1>(newMockEvent())
+
+  exampleEvent1Event.parameters = new Array()
+
+  exampleEvent1Event.parameters.push(
+    new ethereum.EventParam(\"a\", ethereum.Value.fromFixedBytes(a))
+  )
+
+  return exampleEvent1Event
+}
+`)
+  })
+
+  test('Test Files (for indexing events)', () => {
+    const files = scaffoldWithIndexEvents.generateTests()
+    const testFile = files['contract.test.ts']
+    const utilsFile = files['contract-utils.ts']
+
+    expect(testFile).toEqual(`\
+import {
+  assert,
+  describe,
+  test,
+  clearStore,
+  beforeAll,
+  afterAll
+} from \"matchstick-as/assembly/index\"
+import { BigInt, Bytes } from \"@graphprotocol/graph-ts\"
+import { ExampleEvent } from \"../generated/schema\"
+import { ExampleEvent as ExampleEventEvent } from \"../generated/Contract/Contract\"
+import { handleExampleEvent } from \"../src/contract\"
+import { createExampleEventEvent } from \"./contract-utils\"
+
+// Tests structure (matchstick-as >=0.5.0)
+// https://thegraph.com/docs/en/developer/matchstick/#tests-structure-0-5-0
+
+describe(\"Describe entity assertions\", () => {
+  beforeAll(() => {
+    let a = BigInt.fromI32(234)
+    let b = [Bytes.fromI32(1234567890)]
+    let param2 = \"Example string value\"
+    let c = \"ethereum.Tuple Not implemented\"
+    let d = \"Example string value\"
+    let newExampleEventEvent = createExampleEventEvent(a, b, param2, c, d)
+    handleExampleEvent(newExampleEventEvent)
+  })
+
+  afterAll(() => {
+    clearStore()
+  })
+
+  // For more test scenarios, see:
+  // https://thegraph.com/docs/en/developer/matchstick/#write-a-unit-test
+
+  test(\"ExampleEvent created and stored\", () => {
+    assert.entityCount(\"ExampleEvent\", 1)
+
+    // 0xa16081f360e3847006db660bae1c6d1b2e17ec2a is the default address used in newMockEvent() function
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"a\",
+      \"234\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"b\",
+      \"[1234567890]\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"param2\",
+      \"Example string value\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"c\",
+      \"ethereum.Tuple Not implemented\"
+    )
+    assert.fieldEquals(
+      \"ExampleEvent\",
+      \"0xa16081f360e3847006db660bae1c6d1b2e17ec2a-1\",
+      \"d\",
+      \"Example string value\"
+    )
+
+    // More assert options:
+    // https://thegraph.com/docs/en/developer/matchstick/#asserts
+  })
+})
+`)
+    expect(utilsFile).toEqual(`\
+import { newMockEvent } from \"matchstick-as\"
+import { ethereum, BigInt, Bytes } from \"@graphprotocol/graph-ts\"
+import { ExampleEvent, ExampleEvent1 } from \"../generated/Contract/Contract\"
+
+export function createExampleEventEvent(
+  a: BigInt,
+  b: Array<Bytes>,
+  param2: string,
+  c: ethereum.Tuple,
+  d: string
+): ExampleEvent {
+  let exampleEventEvent = changetype<ExampleEvent>(newMockEvent())
+
+  exampleEventEvent.parameters = new Array()
+
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"a\", ethereum.Value.fromUnsignedBigInt(a))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"b\", ethereum.Value.fromBytesArray(b))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"param2\", ethereum.Value.fromString(param2))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"c\", ethereum.Value.fromTuple(c))
+  )
+  exampleEventEvent.parameters.push(
+    new ethereum.EventParam(\"d\", ethereum.Value.fromString(d))
+  )
+
+  return exampleEventEvent
+}
+
+export function createExampleEvent1Event(a: Bytes): ExampleEvent1 {
+  let exampleEvent1Event = changetype<ExampleEvent1>(newMockEvent())
+
+  exampleEvent1Event.parameters = new Array()
+
+  exampleEvent1Event.parameters.push(
+    new ethereum.EventParam(\"a\", ethereum.Value.fromFixedBytes(a))
+  )
+
+  return exampleEvent1Event
+}
 `)
   })
 })

package/src/scaffold/index.js

@@ -15,6 +15,7 @@ const {
   generateExampleEntityType,
 } = require('./schema')
 const { generateEventIndexingHandlers } = require('./mapping')
+const { generateTestsFiles } = require('./tests')
 const { getSubgraphBasename } = require('../command-helpers/subgraph')
 
 module.exports = class Scaffold {
@@ -48,11 +49,13 @@ module.exports = class Scaffold {
             `--node http://localhost:8020/ ` +
             `--ipfs http://localhost:5001 ` +
             this.subgraphName,
+          'test': 'graph test',
         },
         dependencies: {
           '@graphprotocol/graph-cli': GRAPH_CLI_VERSION,
-          '@graphprotocol/graph-ts': `0.27.0`,
+          '@graphprotocol/graph-ts': `0.28.0-alpha.0`,
         },
+        devDependencies: this.protocol.hasEvents() ? { 'matchstick-as': `0.5.0`} : undefined,
       }),
       { parser: 'json' },
     )
@@ -137,6 +140,17 @@ dataSources:
       : undefined
   }
 
+  generateTests() {
+    const hasEvents = this.protocol.hasEvents()
+    const events = hasEvents
+      ? abiEvents(this.abi).toJS()
+      : []
+
+    return events.length > 0
+      ?  generateTestsFiles(this.contractName, events, this.indexEvents)
+      : undefined
+  }
+
   generate() {
     return {
       'package.json': this.generatePackageJson(),
@@ -145,6 +159,7 @@ dataSources:
       'tsconfig.json': this.generateTsConfig(),
       src: { [`${strings.kebabCase(this.contractName)}.ts`]: this.generateMapping() },
       abis: this.generateABIs(),
+      tests: this.generateTests(),
     }
   }
 }

package/src/scaffold/tests.js

@@ -0,0 +1,196 @@
+const prettier = require('prettier')
+const { strings } = require('gluegun')
+const { ascTypeForEthereum, ethereumFromAsc } = require("../codegen/types")
+
+const VARIABLES_VALUES = {
+  "i32": 123,
+  "BigInt": 234,
+  "Bytes": 1234567890,
+  "Address": "0x0000000000000000000000000000000000000001",
+  "string": "Example string value",
+  "bool": true,
+}
+
+const generateTestsFiles = (contract, events, indexEvents) => {
+  const eventsTypes = events
+    .flatMap(event =>
+      event
+        .inputs
+        .map(input => {
+          // If the asc type is Array<T> we need to check if T is a native type or a custom graph-ts type
+          // If we don't do that we may miss a type that should be imported from graph-ts
+          const ascType = ascTypeForEthereum(input.type)
+          const inner = fetchArrayInnerType(ascType)
+          return inner ? inner[1] : ascType
+        })
+    ).filter(type => !type.startsWith("ethereum.") && !isNativeType(type))
+  const importTypes = [...new Set(eventsTypes)].join(', ')
+
+  return {
+    [`${strings.kebabCase(contract)}.test.ts`]: prettier.format(generateExampleTest(contract, events[0], indexEvents, importTypes), { parser: 'typescript', semi: false }),
+    [`${strings.kebabCase(contract)}-utils.ts`]: prettier.format(generateTestHelper(contract, events, importTypes), { parser: 'typescript', semi: false }),
+  }
+}
+
+/*
+  Generates the arguments that will be passed to the mock event function from the event inputs. Example:
+  let id = BigInt.fromI32(234)
+  let owner = Address.fromString("0x0000000000000000000000000000000000000001")
+  let displayName = "Example string value"
+  let imageUrl = "Example string value"
+*/
+const generateArguments = (eventInputs) => {
+  return eventInputs.map((input, index) => {
+    let ascType = ascTypeForEthereum(input.type)
+    return `let ${input.name || `param${index}`} = ${assignValue(ascType, input.name)}`
+  }).join('\n')
+}
+
+// Generates the value that will be assigned to a variable in generateArguments()
+const assignValue = (type) => {
+  switch (type) {
+    case "string":
+      return `"${VARIABLES_VALUES[type]}"`
+    case "BigInt":
+      return `BigInt.fromI32(${VARIABLES_VALUES[type]})`
+    case "Address":
+      return `Address.fromString("${VARIABLES_VALUES[type]}")`
+    case "Bytes":
+      return `Bytes.fromI32(${VARIABLES_VALUES[type]})`
+    case fetchArrayInnerType(type)?.input:
+      innerType = fetchArrayInnerType(type)[1]
+      return `[${assignValue(innerType)}]`
+    default:
+      let value = VARIABLES_VALUES[type]
+      return value ? value : `"${type} Not implemented"`
+  }
+}
+
+/*
+  Generates the assert.fieldEquals() for a given entity and event inputs. Example:
+  assert.fieldEquals(
+    "ExampleEntity",
+    "0xa16081f360e3847006db660bae1c6d1b2e17ec2a",
+    "owner",
+    "0x0000000000000000000000000000000000000001"
+  )
+*/
+const generateFieldsAssertions = (entity, eventInputs, indexEvents) => eventInputs.filter(input => input.name != "id").map((input, index) =>
+  `assert.fieldEquals(
+    "${entity}",
+    "0xa16081f360e3847006db660bae1c6d1b2e17ec2a${indexEvents ? "-1" : ""}",
+    "${input.name || `param${index}`}",
+    "${expectedValue(ascTypeForEthereum(input.type))}"
+  )`
+).join('\n')
+
+// Returns the expected value for a given type in generateFieldsAssertions()
+const expectedValue = type => {
+  switch (type) {
+    case fetchArrayInnerType(type)?.input:
+      innerType = fetchArrayInnerType(type)[1]
+      return `[${expectedValue(innerType)}]`
+    default:
+      let value = VARIABLES_VALUES[type]
+      return value ? value : `${type} Not implemented`
+  }
+}
+
+// Checks if the type is a native AS type or should be imported from graph-ts
+const isNativeType = type => {
+  let natives = [
+    /i32/,
+    /string/,
+    /boolean/
+  ]
+
+  return natives.some(rx => rx.test(type));
+}
+
+const fetchArrayInnerType = type => type.match(/Array<(.*?)>/)
+
+// Generates the example test.ts file
+const generateExampleTest = (contract, event, indexEvents, importTypes) => {
+  const entity = indexEvents ? `${event._alias}` : 'ExampleEntity'
+  const eventInputs = event.inputs
+  const eventName = event._alias
+
+  return `
+  import { assert, describe, test, clearStore, beforeAll, afterAll } from "matchstick-as/assembly/index"
+  import { ${importTypes} } from "@graphprotocol/graph-ts"
+  import { ${entity} } from "../generated/schema"
+  import { ${indexEvents ? `${eventName} as ${eventName}Event` : eventName} } from "../generated/${contract}/${contract}"
+  import { handle${eventName} } from "../src/${strings.kebabCase(contract)}"
+  import { create${eventName}Event } from "./${strings.kebabCase(contract)}-utils"
+
+
+  // Tests structure (matchstick-as >=0.5.0)
+  // https://thegraph.com/docs/en/developer/matchstick/#tests-structure-0-5-0
+
+  describe("Describe entity assertions", () => {
+    beforeAll(() => {
+      ${generateArguments(eventInputs)}
+      let new${eventName}Event = create${eventName}Event(${eventInputs.map((input, index) => input.name || `param${index}`).join(', ')});
+      handle${eventName}(new${eventName}Event)
+    })
+
+    afterAll(() => {
+      clearStore()
+    })
+
+    // For more test scenarios, see:
+    // https://thegraph.com/docs/en/developer/matchstick/#write-a-unit-test
+
+    test("${entity} created and stored", () => {
+      assert.entityCount('${entity}', 1)
+
+      // 0xa16081f360e3847006db660bae1c6d1b2e17ec2a is the default address used in newMockEvent() function
+      ${generateFieldsAssertions(entity, eventInputs, indexEvents)}
+
+      // More assert options:
+      // https://thegraph.com/docs/en/developer/matchstick/#asserts
+    })
+  })
+`
+}
+
+// Generates the utils helper file
+const generateTestHelper = (contract, events, importTypes) => {
+  const eventsNames = events.map(event => event._alias)
+
+  return `
+  import { newMockEvent } from 'matchstick-as';
+  import { ethereum, ${importTypes} } from '@graphprotocol/graph-ts';
+  import { ${eventsNames.join(", ")} } from '../generated/${contract}/${contract}';
+
+  ${generateMockedEvents(events).join("\n")}`
+}
+
+const generateMockedEvents = events =>
+  events.reduce(
+    (acc, event) => acc.concat(generateMockedEvent(event)),
+    [],
+  )
+
+const generateMockedEvent = event => {
+  const varName = `${strings.camelCase(event._alias)}Event`
+  const fnArgs = event.inputs.map((input, index) => `${input.name || `param${index}`}: ${ascTypeForEthereum(input.type)}`);
+  const ascToEth = event.inputs.map((input, index) => `${varName}.parameters.push(new ethereum.EventParam("${input.name || `param${index}`}", ${ethereumFromAsc(input.name || `param${index}`, input.type)}))`);
+
+  return `
+    export function create${event._alias}Event(${fnArgs.join(', ')}): ${event._alias} {
+      let ${varName} = changetype<${event._alias}>(newMockEvent());
+
+      ${varName}.parameters = new Array();
+
+      ${ascToEth.join('\n')}
+
+      return ${varName};
+    }
+  `
+
+}
+
+module.exports = {
+  generateTestsFiles,
+}

package/src/subgraph.js

@@ -216,20 +216,26 @@ More than one template named '${name}', template names must be unique.`,
   static async load(filename, { protocol, skipValidation } = { skipValidation: false }) {
     // Load and validate the manifest
     let data = null
+    let has_file_data_sources = false
 
     if (filename.match(/.js$/)) {
       data = require(path.resolve(filename))
     } else {
-      data = yaml.parse(await fs.readFile(filename, 'utf-8'))
+      let raw_data = await fs.readFile(filename, 'utf-8')
+      has_file_data_sources = raw_data.includes('kind: file')
+      data = yaml.parse(raw_data)
     }
 
     // Helper to resolve files relative to the subgraph manifest
     let resolveFile = maybeRelativeFile =>
       path.resolve(path.dirname(filename), maybeRelativeFile)
 
-    let manifestErrors = await Subgraph.validate(data, protocol, { resolveFile })
-    if (manifestErrors.size > 0) {
-      throwCombinedError(filename, manifestErrors)
+    // TODO: Validation for file data sources
+    if (!has_file_data_sources) {
+      let manifestErrors = await Subgraph.validate(data, protocol, { resolveFile })
+      if (manifestErrors.size > 0) {
+        throwCombinedError(filename, manifestErrors)
+      }
     }
 
     let manifest = immutable.fromJS(data)