graphbrainz/test/_schema.js

import test from 'ava'
import { graphql } from 'graphql'
import schemas from './helpers/schema'
import context from './helpers/context'

const TEST_SCHEMA = process.env.TEST_SCHEMA || 'baseSchema'
const schema = schemas[TEST_SCHEMA]

function testData(t, query, handler) {
  return graphql(schema, query, null, context).then(result => {
    if (result.errors !== undefined) {
      console.log(result.errors)
    }
    t.is(result.errors, undefined)
    return handler(t, result.data)
  })
}

function testError(t, query, handler) {
  return graphql(schema, query, null, context).then(result => {
    t.truthy(result.errors)
    t.true(result.errors.length > 0)
    return handler(t, result.errors)
  })
}

function testThrows(t, query, handler) {
  const error = t.throws(graphql(schema, query, null, context))
  return handler(t, error)
}

test(
  'schema has a node field',
  testData,
  `
  {
    node(id: "UmVsZWFzZUdyb3VwOmUzN2QyNzQwLTQ1MDMtNGUzZi1hYjZkLWU2MjJhMjVlOTY0ZA==") {
      __typename
      ... on ReleaseGroup {
        mbid
      }
    }
  }
`,
  (t, data) => {
    t.deepEqual(data, {
      node: {
        __typename: 'ReleaseGroup',
        mbid: 'e37d2740-4503-4e3f-ab6d-e622a25e964d'
      }
    })
  }
)

test(
  'schema has a lookup query',
  testData,
  `
  {
    lookup {
      artist (mbid: "c8da2e40-bd28-4d4e-813a-bd2f51958ba8") {
        mbid
        name
        type
      }
    }
  }
`,
  (t, data) => {
    t.deepEqual(data, {
      lookup: {
        artist: {
          mbid: 'c8da2e40-bd28-4d4e-813a-bd2f51958ba8',
          name: 'Lures',
          type: 'Group'
        }
      }
    })
  }
)

test(
  'schema has a search query',
  testData,
  `
  {
    search {
      recordings (query: "Burn the Witch") {
        totalCount
        edges {
          score
          node {
            mbid
            title
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { recordings } = data.search
    t.true(recordings.totalCount > 0)
    t.true(recordings.edges.length === 25)
    recordings.edges.forEach(edge => t.true(edge.score > 0))
  }
)

test(
  'schema has a browse query',
  testData,
  `
  {
    browse {
      releaseGroups(artist: "c8da2e40-bd28-4d4e-813a-bd2f51958ba8") {
        totalCount
        edges {
          node {
            mbid
            title
            artistCredit {
              artist {
                mbid
              }
              name
              joinPhrase
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { releaseGroups } = data.browse
    t.true(releaseGroups.totalCount > 0)
    t.true(releaseGroups.edges.length > 0)
    releaseGroups.edges.forEach(edge => t.truthy(edge.node.title))
  }
)

test(
  'supports deeply nested queries',
  testData,
  `
  query AppleRecordsMarriages {
    search {
      labels(query: "Apple Records", first: 1) {
        edges {
          node {
            name
            disambiguation
            country
            releases(first: 1) {
              edges {
                node {
                  title
                  date
                  artists {
                    edges {
                      node {
                        name
                        ...bandMembers
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  fragment bandMembers on Artist {
    relationships {
      artists(direction: "backward", type: "member of band") {
        edges {
          node {
            type
            target {
              ... on Artist {
                name
                ...marriages
              }
            }
          }
        }
      }
    }
  }

  fragment marriages on Artist {
    relationships {
      artists(type: "married") {
        edges {
          node {
            type
            direction
            begin
            end
            target {
              ... on Artist {
                name
              }
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { labels } = data.search
    t.true(labels.edges.length > 0)
    t.is(labels.edges[0].node.releases.edges.length, 1)
  }
)

test(
  'connections have a nodes shortcut field',
  testData,
  `
  query AppleRecordsMarriages {
    search {
      labels(query: "Apple Records", first: 1) {
        nodes {
          name
          disambiguation
          country
          releases(first: 1) {
            nodes {
              title
              date
              artists {
                nodes {
                  name
                  ...bandMembers
                }
              }
            }
          }
        }
      }
    }
  }

  fragment bandMembers on Artist {
    relationships {
      artists(direction: "backward", type: "member of band") {
        nodes {
          type
          target {
            ... on Artist {
              name
              ...marriages
            }
          }
        }
      }
    }
  }

  fragment marriages on Artist {
    relationships {
      artists(type: "married") {
        nodes {
          type
          direction
          begin
          end
          target {
            ... on Artist {
              name
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { labels } = data.search
    t.true(labels.nodes.length > 0)
    t.is(labels.nodes[0].releases.nodes.length, 1)
  }
)

// FIXME: https://github.com/graphql/graphql-js/issues/910
test(
  'throws an error if given a malformed MBID',
  testThrows,
  `
  {
    lookup {
      artist(mbid: "ABC123") {
        name
      }
    }
  }
`,
  async (t, promise) => {
    const err = await promise
    t.true(err instanceof TypeError)
    t.is(err.message, 'Malformed MBID: ABC123')
  }
)

test(
  'artist areas access begin_area/end_area for lookup queries',
  testData,
  `
  {
    lookup {
      artist(mbid: "65314b12-0e08-43fa-ba33-baaa7b874c15") {
        beginArea {
          name
        }
        endArea {
          name
        }
      }
    }
  }
`,
  (t, data) => {
    const { artist } = data.lookup
    t.is(artist.beginArea.name, 'Westmount')
    t.is(artist.endArea.name, 'Los Angeles')
  }
)

test(
  'artist areas access begin_area/end_area for browse queries',
  testData,
  `
  {
    browse {
      artists(area: "3f504d54-c40c-487d-bc16-c1990eac887f") {
        edges {
          node {
            beginArea {
              name
            }
            endArea {
              name
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const artists = data.browse.artists.edges.map(edge => edge.node)
    t.true(artists.length > 1)
    t.true(artists.some(artist => artist.beginArea))
    t.true(artists.some(artist => artist.endArea))
  }
)

test(
  'artist areas access begin-area/end-area for search queries',
  testData,
  `
  {
    search {
      artists(query: "Leonard Cohen", first: 1) {
        edges {
          node {
            beginArea {
              name
            }
            endArea {
              name
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const artists = data.search.artists.edges.map(edge => edge.node)
    t.true(artists.length === 1)
    t.is(artists[0].beginArea.name, 'Westmount')
    t.is(artists[0].endArea.name, 'Los Angeles')
  }
)

test(
  'relationships are grouped by target type',
  testData,
  `
  {
    lookup {
      artist(mbid: "65314b12-0e08-43fa-ba33-baaa7b874c15") {
        relationships {
          artists(first: 5) {
            edges {
              node {
                target {
                  __typename
                }
                targetType
              }
            }
          }
          recordings(first: 5) {
            edges {
              node {
                target {
                  __typename
                }
                targetType
              }
            }
          }
          releases(first: 5) {
            edges {
              node {
                target {
                  __typename
                }
                targetType
              }
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { relationships } = data.lookup.artist
    t.is(relationships.artists.edges.length, 5)
    relationships.artists.edges.forEach(edge => {
      t.is(edge.node.targetType, 'artist')
      t.is(edge.node.target.__typename, 'Artist')
    })
    t.is(relationships.recordings.edges.length, 5)
    relationships.recordings.edges.forEach(edge => {
      t.is(edge.node.targetType, 'recording')
      t.is(edge.node.target.__typename, 'Recording')
    })
    t.is(relationships.releases.edges.length, 5)
    relationships.releases.edges.forEach(edge => {
      t.is(edge.node.targetType, 'release')
      t.is(edge.node.target.__typename, 'Release')
    })
  }
)

test(
  'relationships can be filtered by type',
  testData,
  `
  {
    lookup {
      artist(mbid: "65314b12-0e08-43fa-ba33-baaa7b874c15") {
        relationships {
          artists(type: "parent") {
            edges {
              node {
                targetType
                type
              }
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { artist } = data.lookup
    const rels = artist.relationships.artists.edges.map(edge => edge.node)
    t.is(rels.length, 2)
    rels.forEach(rel => {
      t.is(rel.targetType, 'artist')
      t.is(rel.type, 'parent')
    })
  }
)

test(
  'relationships can be filtered by type ID',
  testData,
  `
  {
    lookup {
      artist(mbid: "65314b12-0e08-43fa-ba33-baaa7b874c15") {
        relationships {
          artists(typeID: "fd3927ba-fd51-4fa9-bcc2-e83637896fe8") {
            edges {
              node {
                targetType
                type
              }
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { artist } = data.lookup
    const rels = artist.relationships.artists.edges.map(edge => edge.node)
    t.is(rels.length, 1)
    rels.forEach(rel => {
      t.is(rel.targetType, 'artist')
      t.is(rel.type, 'involved with')
    })
  }
)

test(
  'relationships can be filtered by direction',
  testData,
  `
  {
    lookup {
      area(mbid: "10cb2ebd-1bc7-4c11-b10d-54f60c421d20") {
        relationships {
          isPartOf: areas(direction: "backward") {
            edges {
              node {
                type
                direction
              }
            }
          }
          hasParts: areas(direction: "forward") {
            edges {
              node {
                type
                direction
              }
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { area } = data.lookup
    const isPartOf = area.relationships.isPartOf.edges.map(edge => edge.node)
    const hasParts = area.relationships.hasParts.edges.map(edge => edge.node)
    t.true(isPartOf.length > 0)
    t.true(hasParts.length > 0)
    isPartOf.forEach(rel => {
      t.is(rel.type, 'part of')
      t.is(rel.direction, 'backward')
    })
    hasParts.forEach(rel => {
      t.is(rel.type, 'part of')
      t.is(rel.direction, 'forward')
    })
  }
)

test(
  'area maps iso-3166-1-codes to isoCodes',
  testData,
  `
  {
    lookup {
      area(mbid: "489ce91b-6658-3307-9877-795b68554c98") {
        name
        isoCodes
      }
    }
  }
`,
  (t, data) => {
    t.deepEqual(data.lookup.area.isoCodes, ['US'])
  }
)

test(
  'areas have a type and typeID',
  testData,
  `
  {
    search {
      areas(query: "Germany", first: 5) {
        nodes {
          name
          type
          typeID
        }
      }
    }
  }
`,
  (t, data) => {
    t.snapshot(data)
  }
)

test(
  'alias locales use the locale scalar',
  testData,
  `
  {
    lookup {
      artist(mbid: "f99b7d67-4e63-4678-aa66-4c6ac0f7d24a") {
        aliases {
          name
          locale
        }
      }
    }
  }
`,
  (t, data) => {
    const { aliases } = data.lookup.artist
    t.is(aliases.find(alias => alias.locale === 'en').name, 'PSY')
    t.is(aliases.find(alias => alias.locale === 'ko').name, '싸이')
  }
)

test(
  'work ISWCs use the ISWC scalar',
  testData,
  `
  {
    lookup {
      work(mbid: "ef7d0814-da6a-32f5-a600-ff81cffd1aed") {
        title
        iswcs
      }
    }
  }
`,
  (t, data) => {
    const { work } = data.lookup
    t.is(work.title, 'Song of the French Partisan')
    t.deepEqual(work.iswcs, ['T-900.755.682-3'])
  }
)

test(
  'URLs may be looked up by resource',
  testData,
  `
  {
    lookup {
      url(resource: "http://www.nirvana.com/") {
        mbid
        resource
      }
    }
  }
`,
  (t, data) => {
    const { url } = data.lookup
    t.is(url.mbid, '4347ffe2-82ec-4059-9520-6a1a3f73a304')
    t.is(url.resource, 'http://www.nirvana.com/')
  }
)

// FIXME: https://github.com/graphql/graphql-js/issues/910
test(
  'throws an error if given a malformed resource URL',
  testThrows,
  `
  {
    lookup {
      url(resource: "http:foo") {
        mbid
        resource
      }
    }
  }
`,
  async (t, promise) => {
    const err = await promise
    t.true(err instanceof TypeError)
    t.is(err.message, 'Malformed URL: http:foo')
  }
)

test(
  'release groups can be browsed by type',
  testData,
  `
  {
    browse {
      releaseGroups(artist: "5b11f4ce-a62d-471e-81fc-a69a8278c7da", type: EP) {
        edges {
          node {
            primaryType
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const releaseGroups = data.browse.releaseGroups.edges.map(edge => edge.node)
    t.is(releaseGroups.length, 8)
    releaseGroups.forEach(releaseGroup => t.is(releaseGroup.primaryType, 'EP'))
  }
)

test(
  'releases can be browsed by type and status',
  testData,
  `
  {
    browse {
      releases(artist: "5b11f4ce-a62d-471e-81fc-a69a8278c7da", type: EP, status: BOOTLEG) {
        edges {
          node {
            status
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const releases = data.browse.releases.edges.map(edge => edge.node)
    t.is(releases.length, 6)
    releases.forEach(release => t.is(release.status, 'BOOTLEG'))
  }
)

test(
  'releases have an ASIN field',
  testData,
  `
  {
    lookup {
      release(mbid: "d5cdb7fd-c7e9-460a-9549-8a369655cc52") {
        asin
      }
    }
  }
`,
  (t, data) => {
    const { release } = data.lookup
    t.is(release.asin, 'B01KN6XDS6')
  }
)

test(
  'artists have a list of ISNIs and IPIs',
  testData,
  `
  {
    lookup {
      artist(mbid: "65314b12-0e08-43fa-ba33-baaa7b874c15") {
        ipis
        isnis
      }
    }
  }
`,
  (t, data) => {
    const { artist } = data.lookup
    t.deepEqual(artist.ipis, ['00006457004'])
    t.deepEqual(artist.isnis, ['0000000110273481'])
  }
)

test(
  'artistCredits is an alias for artistCredit',
  testData,
  `
  {
    lookup {
      recording(mbid: "07649758-09c8-4d70-bc6f-5c37ab36334d") {
        artistCredit {
          name
          joinPhrase
        }
        artistCredits {
          name
          joinPhrase
        }
      }
      release(mbid: "d5cdb7fd-c7e9-460a-9549-8a369655cc52") {
        artistCredit {
          name
          joinPhrase
        }
        artistCredits {
          name
          joinPhrase
        }
      }
      releaseGroup(mbid: "53614893-6f25-4519-9cae-b1db904e2887") {
        artistCredit {
          name
          joinPhrase
        }
        artistCredits {
          name
          joinPhrase
        }
      }
    }
  }
`,
  (t, data) => {
    const { recording, release, releaseGroup } = data.lookup
    t.deepEqual(recording.artistCredit, [
      { name: 'Holly Golightly', joinPhrase: ' & ' },
      { name: 'The Brokeoffs', joinPhrase: '' }
    ])
    t.deepEqual(recording.artistCredits, recording.artistCredit)

    t.deepEqual(release.artistCredit, [
      { name: 'Leonard Cohen', joinPhrase: '' }
    ])
    t.deepEqual(release.artistCredits, release.artistCredit)

    t.deepEqual(releaseGroup.artistCredit, [
      { name: 'DJ Muggs', joinPhrase: ' vs. ' },
      { name: 'Ill Bill', joinPhrase: '' }
    ])
    t.deepEqual(releaseGroup.artistCredits, releaseGroup.artistCredit)
  }
)

test(
  'recordings can be browsed by ISRC',
  testData,
  `
  {
    browse {
      recordings(isrc: "USSUB0200002") {
        totalCount
        edges {
          node {
            title
            isrcs
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const recordings = data.browse.recordings.edges.map(edge => edge.node)
    t.is(data.browse.recordings.totalCount, 1)
    t.deepEqual(recordings, [
      { title: 'About a Girl', isrcs: ['USSUB0200002', 'USUG10200084'] }
    ])
  }
)

test(
  'releases can be browsed by Disc ID',
  testData,
  `
  {
    browse {
      releases(discID: "XzPS7vW.HPHsYemQh0HBUGr8vuU-") {
        totalCount
        edges {
          node {
            mbid
            title
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const releases = data.browse.releases.edges.map(edge => edge.node)
    t.true(data.browse.releases.totalCount >= 2)
    t.true(
      releases.some(
        release => release.mbid === '5a6e5ad7-c2bd-3484-a20e-121bf981c883'
      )
    )
    t.true(
      releases.some(
        release => release.mbid === '96f6f90e-d831-4f37-bf72-ce2982e459fb'
      )
    )
  }
)

test(
  'works can be browsed by ISWC',
  testData,
  `
  {
    browse {
      works(iswc: "T-900.755.682-3") {
        totalCount
        edges {
          node {
            title
            iswcs
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const works = data.browse.works.edges.map(edge => edge.node)
    t.is(data.browse.works.totalCount, 1)
    t.deepEqual(works, [
      { title: 'Song of the French Partisan', iswcs: ['T-900.755.682-3'] }
    ])
  }
)

test(
  'recordings have a length in milliseconds',
  testData,
  `
  {
    lookup {
      recording(mbid: "9f9cf187-d6f9-437f-9d98-d59cdbd52757") {
        length
      }
    }
  }
`,
  (t, data) => {
    const { recording } = data.lookup
    t.is(recording.length, 383493)
  }
)

test(
  'collections can be browsed by the entities they contain',
  testData,
  `
  {
    browse {
      collections(artist: "24f1766e-9635-4d58-a4d4-9413f9f98a4c") {
        totalCount
        edges {
          node {
            name
            editor
            entityType
            type
            artists {
              totalCount
              edges {
                node {
                  mbid
                  name
                }
              }
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const collections = data.browse.collections.edges.map(edge => edge.node)
    t.true(collections.length >= 2)
    t.true(collections.some(collection => collection.editor === 'arist.on'))
    t.true(
      collections.some(collection => collection.editor === 'ListMyCDs.com')
    )
    collections.forEach(collection => {
      t.is(collection.entityType, 'artist')
      t.is(collection.type, 'Artist')
      t.true(collection.artists.totalCount > 0)
      t.true(collection.artists.edges.length > 0)
    })
  }
)

test(
  'collections can be looked up by MBID',
  testData,
  `
  {
    lookup {
      collection(mbid: "85da782d-2ec0-41ec-a97f-9be464bba309") {
        name
        releases {
          edges {
            node {
              title
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { collection } = data.lookup
    t.is(collection.name, 'Beets Music Collection')
    t.is(collection.releases.edges.length, 25)
  }
)

test(
  'entities have a collections field',
  testData,
  `
  {
    lookup {
      release(mbid: "0702057c-cb90-43d3-b7b4-6d0cc37e8644") {
        title
        collections {
          totalCount
          edges {
            node {
              editor
            }
          }
        }
      }
      artist(mbid: "24f1766e-9635-4d58-a4d4-9413f9f98a4c") {
        name
        collections {
          totalCount
          edges {
            node {
              editor
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { release, artist } = data.lookup
    t.true(release.collections.totalCount > 0)
    t.true(release.collections.edges.length > 0)
    t.true(artist.collections.edges.length > 0)
  }
)

test(
  'releases support a list of media',
  testData,
  `
  {
    lookup {
      release(mbid: "a4864e94-6d75-4ade-bc93-0dabf3521453") {
        media {
          title
          format
          formatID
          position
          trackCount
        }
      }
    }
  }
`,
  (t, data) => {
    const { release } = data.lookup
    t.deepEqual(release.media, [
      {
        title: 'Left',
        format: 'CD',
        formatID: '9712d52a-4509-3d4b-a1a2-67c88c643e31',
        position: 1,
        trackCount: 12
      },
      {
        title: 'Right',
        format: 'CD',
        formatID: '9712d52a-4509-3d4b-a1a2-67c88c643e31',
        position: 2,
        trackCount: 11
      }
    ])
  }
)

test(
  'throws an error if looking up a URL without an argument',
  testError,
  `
  {
    lookup {
      url {
        mbid
      }
    }
  }
`,
  (t, errors) => {
    t.is(
      errors[0].message,
      'Lookups by a field other than MBID must provide: resource'
    )
  }
)

test(
  'some entities support ratings',
  testData,
  `
  {
    lookup {
      event(mbid: "eec75a81-8864-4cea-b8b4-e99cd08b29f1") {
        rating {
          voteCount
          value
        }
      }
      work(mbid: "12b53203-64af-3a94-b3ec-11fad7c7d809") {
        rating {
          voteCount
          value
        }
      }
    }
    browse {
      artists(work: "8a25ce1e-8695-42c0-b668-8f0aa057c72b") {
        edges {
          node {
            rating {
              voteCount
              value
            }
          }
        }
      }
      recordings(artist: "c8da2e40-bd28-4d4e-813a-bd2f51958ba8") {
        edges {
          node {
            rating {
              voteCount
              value
            }
          }
        }
      }
    }
    search {
      labels(query: "Fin Records") {
        edges {
          node {
            rating {
              voteCount
              value
            }
          }
        }
      }
      releaseGroups(query: "arid:c8da2e40-bd28-4d4e-813a-bd2f51958ba8") {
        edges {
          node {
            rating {
              voteCount
              value
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { event, work } = data.lookup
    const artists = data.browse.artists.edges.map(edge => edge.node)
    const recordings = data.browse.recordings.edges.map(edge => edge.node)
    const labels = data.search.labels.edges.map(edge => edge.node)
    const releaseGroups = data.search.releaseGroups.edges.map(edge => edge.node)
    t.is(event.rating.voteCount, 0)
    t.is(event.rating.value, null)
    t.true(work.rating.voteCount > 0)
    t.true(work.rating.value >= 4)
    t.true(artists.some(artist => artist.rating.voteCount > 0))
    t.true(artists.some(artist => artist.rating.value > 3))
    t.true(recordings.some(recording => recording.rating.voteCount > 0))
    t.true(recordings.some(recording => recording.rating.value > 3))
    t.true(labels.some(label => label.rating.voteCount > 0))
    t.true(labels.some(label => label.rating.value > 3))
    t.true(
      releaseGroups.some(releaseGroup => releaseGroup.rating.voteCount > 0)
    )
    t.true(releaseGroups.some(releaseGroup => releaseGroup.rating.value > 3))
  }
)

test(
  'discs can be looked up by disc ID',
  testData,
  `
  {
    lookup {
      disc(discID: "TMXdzZkTcc9Jq24PD0w5J9_AXms-") {
        id
        discID
        offsetCount
        offsets
        sectors
        releases {
          totalCount
          edges {
            node {
              mbid
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { disc } = data.lookup
    t.is(disc.discID, 'TMXdzZkTcc9Jq24PD0w5J9_AXms-')
    t.is(disc.offsetCount, 9)
    t.is(disc.sectors, 193443)
    t.deepEqual(disc.offsets, [
      150,
      18190,
      34163,
      66150,
      87453,
      116853,
      151413,
      166833,
      184123
    ])
    t.is(disc.releases.totalCount, 1)
    t.is(disc.releases.edges.length, 1)
    t.is(
      disc.releases.edges[0].node.mbid,
      '7f6d3088-837d-495e-905f-be5c70ac2d82'
    )
  }
)

test(
  'release media has a list of discs',
  testData,
  `
  {
    lookup {
      release(mbid: "7f6d3088-837d-495e-905f-be5c70ac2d82") {
        media {
          discs {
            discID
            releases {
              totalCount
              edges {
                node {
                  mbid
                }
              }
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { release } = data.lookup
    t.is(release.media.length, 1)
    t.is(release.media[0].discs.length, 2)
  }
)

test(
  'disc queries can be deeply nested',
  testData,
  `
  {
    lookup {
      disc(discID: "TMXdzZkTcc9Jq24PD0w5J9_AXms-") {
        discID
        offsetCount
        offsets
        sectors
        releases {
          totalCount
          edges {
            node {
              mbid
              title
              date
              media {
                discs {
                  discID
                  releases {
                    edges {
                      node {
                        date
                        media {
                          discs {
                            discID
                            releases {
                              edges {
                                node {
                                  date
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { disc } = data.lookup
    t.true(disc.releases.edges.length > 0)
    disc.releases.edges.forEach(release => {
      t.true(release.node.media.length > 0)
      release.node.media.forEach(medium => {
        t.true(medium.discs.length > 0)
        medium.discs.forEach(disc => {
          t.true(disc.releases.edges.length > 0)
          disc.releases.edges.forEach(release => {
            t.true(release.node.media.length > 0)
            release.node.media.forEach(medium => {
              t.true(medium.discs.length > 0)
            })
          })
        })
      })
    })
  }
)

test(
  'entities support tags',
  testData,
  `
  {
    lookup {
      label(mbid: "38dc88de-7720-4100-9d5b-3cdc41b0c474") {
        tags {
          edges {
            node {
              name
              count
            }
          }
        }
      }
    }
    search {
      artists(query: "Leonard Cohen", first: 1) {
        edges {
          node {
            tags {
              edges {
                node {
                  name
                  count
                }
              }
            }
          }
        }
      }
    }
  }
`,
  (t, data) => {
    const { label } = data.lookup
    const artists = data.search.artists.edges.map(edge => edge.node)
    t.true(label.tags.edges.some(edge => edge.node.name === 'indie folk'))
    t.true(label.tags.edges.some(edge => edge.node.count > 0))
    t.true(artists[0].tags.edges.some(edge => edge.node.name === 'blues rock'))
    t.true(artists[0].tags.edges.some(edge => edge.node.count > 0))
  }
)