TypeScript fetch-mock.post函数代码示例

test('Succeeding auth without token', async t => {

  // configure HTTP mocks
  fetchMock.post(`${authEndpoint}/create`, {})
  fetchMock.get(`${authEndpoint}/*`, {
    authToken: testToken
  })
  fetchMock.post(`${systemAPIEndpoint}`, {
    data: {
      viewer: {
        user: {
          id: 'abcdefghik'
        }
      }
    }
  })

  // configure auth dependencies
  const env = testEnvironment({})
  const authServer = new TestAuthServer()

  env.out.prefix((t as any)._test.title, '$ graphcool auth')

  // authenticate
  await t.notThrows(
    authCommand({}, env, authServer)
  )

  // verify result
  const {token} = JSON.parse(env.resolver.read(graphcoolConfigFilePath))
  t.is(token, testToken)
})

test('Succeeding project clone with specific name and different output path', async t => {

  // configure HTTP mocks
  fetchMock.post(systemAPIEndpoint, JSON.parse(mockedClonedProjectResponse))

  // create dummy project data
  const copyProjectId = 'abcdefghiklmn'
  const clonedProjectName = `Clone of MyProject`
  const outputPath = `myclone.graphcool`
  const props = {name: clonedProjectName, outputPath, copyProjectId}

  // prepare environment
  const env = testEnvironment({})
  const projectFilePath = graphcoolProjectFileName
  env.resolver.write(projectFilePath, mockProjectFile1)
  env.resolver.write(graphcoolConfigFilePath, '{"token": "abcdefgh"}')

  env.out.prefix((t as any)._test.title, `$ graphcool init -n "Clone of MyProject" -o ${outputPath} -c ${copyProjectId} `)

  await t.notThrows(
    init(props, env)
  )

  const expectedProjectFileContent = clonedMockProjectFile1
  const clonedProjectFileName = outputPath
  t.is(env.resolver.read(clonedProjectFileName), expectedProjectFileContent)
  t.is(readProjectIdFromProjectFile(env.resolver, clonedProjectFileName), 'nmlkjihgfedcba')
  t.is(readVersionFromProjectFile(env.resolver, clonedProjectFileName), '1')
})

test('Succeeding project creation with remote schema file', async t => {
  const name = 'MyProject'
  const schemaUrl = 'https://graphqlbin/project.graphql'

  // configure HTTP mocks
  fetchMock.post(systemAPIEndpoint, JSON.parse(mockedCreateProjectResponse))

  const schema = simpleTwitterSchema
  fetchMock.get(schemaUrl, schema)

  // create dummy project data
  const props = {name, schemaUrl}

  // prepare environment
  const env = testEnvironment({})
  env.resolver.write(graphcoolConfigFilePath, '{"token": "abcdefgh"}')

  env.out.prefix((t as any)._test.title, `$ graphcool init -s ${schemaUrl} -n ${name}`)

  await t.notThrows(
    initCommand(props, env)
  )

  const expectedProjectFileContent = mockProjectFile1
  t.is(env.resolver.read(graphcoolProjectFileName), expectedProjectFileContent)
  t.is(readProjectIdFromProjectFile(env.resolver, graphcoolProjectFileName), 'abcdefghijklmn')
  t.is(readVersionFromProjectFile(env.resolver, graphcoolProjectFileName), '1')
})

  beforeEach(() => {
    fetchMock.restore();
    fetchMock.post('begin:batch', makePromise([data, data2]));
    fetchMock.post('begin:rofl', makePromise([roflData, roflData]));
    fetchMock.post('begin:lawl', makePromise([lawlData, lawlData]));

    const next = jest.fn();
    const error = jest.fn();
    const complete = jest.fn();

    subscriber = {
      next,
      error,
      complete,
    };
  });

            it('should return array with identifiers and uris', () => {
                fetchMock.post(
                    '/gdc/md/myFakeProjectId/identifiers',
                    {
                        status: 200,
                        body: JSON.stringify({
                            identifiers: [{
                                uri: '/foo/bar',
                                identifier: 'attr.foo.bar'
                            }, {
                                uri: '/fuzz/buzz',
                                identifier: 'attr.fuzz.buzz'
                            }]
                        })
                    }
                );

                return createMd().getIdentifiersFromUris('myFakeProjectId', ['/foo/bar'])
                    .then((result: any) => {
                        expect(result).toEqual([{
                            uri: '/foo/bar',
                            identifier: 'attr.foo.bar'
                        }, {
                            uri: '/fuzz/buzz',
                            identifier: 'attr.fuzz.buzz'
                        }]);
                    });
            });

test('Pull without project file but passing project ID as argument, result has an alias', async t => {
  const sourceProjectId = 'cj26898xqm9tz0126n34d64ey'

  // configure HTTP mocks
  const mockedResponse = JSON.parse(mockedPullProjectResponseWithAlias1)
  debug(`Mock response: ${JSON.stringify(mockedResponse)}`)
  fetchMock.post(systemAPIEndpoint, mockedResponse)

  // dummy pull data
  const env = testEnvironment({})
  env.resolver.write(graphcoolConfigFilePath, '{"token": ""}')
  const props = { force: true, sourceProjectId}

  env.out.prefix((t as any)._test.title, `$ graphcool pull -s ${sourceProjectId}`)

  await t.notThrows(
    pullCommand(props, env)
  )

  const expectedProjectFileContent = mockedPullProjectFileWithAlias1
  const result = env.resolver.read(graphcoolProjectFileName)

  t.is(result, expectedProjectFileContent)

})

 function mockIntialPost() {
     fetchMock.post(
         '/gdc/md/1/etl/pull2',
         {
             status: 201,
             body: JSON.stringify(triggerEtlResponse)
         }
     );
 }