TypeScript assert.jsonSchema方法代码示例

  it("should fetch invoices", async () => {
    if (!schema) {
      throw new Error("Invoice schema not generated");
    }

    const { state: { token } } = store;

    const resp = await Billing.Invoices.getCollection({
      token,
      query: {},
      settings: {
        url: process.env.API_URL || "",
        project: process.env.PROJECT_ID || "",
      },
    });

    if (!resp.ok) {
      throw new Error(resp.error.title);
    }

    if (!resp.value.data) {
      throw new Error("data field is empty");
    }

    assert.isTrue(resp.ok);
    assert.jsonSchema(resp.value, schema);
  });

    it("should fetch a token", async () => {
      const totpToken = totp({
        secret: process.env.TOTP_SECRET,
        encoding: "base32",
        // tslint:disable-next-line:no-bitwise
        time: (Date.now() / 1000) | 0, // specified in seconds
      });

      const resp = await Auth.passwordGrant(
        {
          email: process.env.EMAIL || "",
          password: process.env.PASSWORD || "",
          client_id: process.env.CLIENT_ID,
          client_secret: process.env.CLIENT_SECRET,
          totp_passcode: totpToken,
        },
        {
          url: process.env.AUTH_URL,
          noVersion: true,
          useHttp: store.state.settings.useHttp,
        },
      );

      if (!resp.ok) {
        throw new Error(resp.error.title);
      }

      assert.isTrue(resp.ok);
      assert.jsonSchema(resp.value, schema);

      // use this token for subsequent requests
      store.updateToken(resp.value);
    });

	export function assertConfig(config:tsd.Config, values:any, message:string) {
		assert.ok(config, message + ': config');
		assert.ok(values, message + ': values');
		assert.instanceOf(config, tsd.Config, message + ': config');

		helper.propStrictEqual(config, values, 'path', message);
		helper.propStrictEqual(config, values, 'version', message);
		helper.propStrictEqual(config, values, 'repo', message);
		helper.propStrictEqual(config, values, 'ref', message);

		if (values.repoOwner) {
			helper.propStrictEqual(config, values, 'repoOwner', message);
		}
		if (values.repoProject) {
			helper.propStrictEqual(config, values, 'repoProject', message);
		}

		var json = config.toJSON();
		assert.jsonSchema(json, helper.getConfigSchema(), message + ': schema');
		helper.propStrictEqual(json, values, 'path', message + ': json');
		helper.propStrictEqual(json, values, 'version', message + ': json');
		helper.propStrictEqual(json, values, 'repo', message + ': json');
		helper.propStrictEqual(json, values, 'ref', message + ': json');
		if (values.installed) {
			assert.like(json.installed, values.installed);
		}
		else {
			assert.like(json.installed, {});
		}
	}

  it("should update account name and revert it back", async () => {
    const { token } = store.state;
    const originalResp = await Account.getSingle({
      token,
      settings: { url: process.env.API_URL },
    });

    if (!originalResp.ok) {
      throw new Error(originalResp.error.title);
    }

    if (!originalResp.value.data) {
      throw new Error("data field is null");
    }

    const value = {
      name: {
        first: "Mike",
        last: "Wizowsky",
      },
    };

    const resp = await Account.update({
      token,
      value,

      query: {},
      settings: { url: process.env.API_URL },
    });

    if (!resp.ok) {
      throw new Error(resp.error.title);
    }

    assert.isTrue(resp.ok);
    assert.jsonSchema(resp.value.data, schema);
    assert.deepPropertyVal(resp.value.data, "name", {
      first: "Mike",
      last: "Wizowsky",
    });

    const revertUpdate = { name: originalResp.value.data.name };
    const revertResp = await Account.update({
      token,
      query: {},
      value: revertUpdate,
      settings: { url: process.env.API_URL },
    });

    if (!revertResp.ok) {
      throw new Error(revertResp.error.title);
    }

    assert.deepPropertyVal(revertResp.value.data, "name", revertUpdate.name);
  });

  it("should fetch project capabilities", async () => {
    if (!schema) {
      throw new Error("Capabilities schema not generated");
    }

    const resp = await Projects.getCapabilities({
      settings: store.state.settings,
    });

    if (!resp.ok) {
      throw new Error(resp.error.title);
    }

    assert.isTrue(resp.ok);
    assert.jsonSchema(resp.value, schema);
  });

  it("should fetch user account", async () => {
    if (!schema) {
      throw new Error("Account schema not generated");
    }
    const { token } = store.state;

    const resp = await Account.getSingle({
      token,
      query: {},
      settings: { url: process.env.API_URL },
    });

    if (!resp.ok) {
      throw new Error(resp.error.title);
    }

    assert.isTrue(resp.ok);
    assert.jsonSchema(resp.value.data, schema);
  });

  it("should fetch notifications", async () => {
    if (!schema) {
      throw new Error("Notification schema not generated");
    }

    const { state: { token } } = store;

    const resp = await Notifications.getCollection({
      token,
      settings: store.state.settings,
    });

    if (!resp.ok) {
      throw new Error(resp.error.title);
    }

    assert.isTrue(resp.ok);
    assert.jsonSchema(resp.value, schema);
  });

  it("should fetch provider datacenters", async () => {
    if (!schema) {
      throw new Error("DC schema not generated");
    }

    const { active: { provider } } = store.state;

    const resp = await Infrastructure.Providers.DataCenters.getCollection({
      provider,
      query: {},
      settings: store.state.settings,
    });

    if (!resp.ok) {
      throw new Error(resp.error.title);
    }

    assert.isTrue(resp.ok);
    assert.jsonSchema(resp.value, schema);
  });

  it("should delete the environment we created", async () => {
    const { token } = store.state;
    const resp = await Environments.remove({
      token,
      id: store.state.active.environment,
      query: {},
      settings: store.state.settings,
    });

    if (!resp.ok) {
      throw new Error(resp.error.title);
    }

    if (!resp.value.data) {
      throw new Error("data field is empty");
    }

    assert.isTrue(resp.ok);
    assert.jsonSchema(resp.value.data, schema);
  });

			}).then((first) => {
				assert.ok(first, 'first data');
				assert.isObject(first, 'first data');
				assert.strictEqual(first.sha, expectedSha, 'first.sha vs expectedSha');

				assert.jsonSchema(first, metaFields, 'first meta');
				fixMeta(first.meta);
				assert.jsonOf(expectedJson, first, 'first vs expectedJson');

				var firstBuffer = git.GitUtil.decodeBlobJson(first);
				assert.instanceOf(firstBuffer, Buffer, 'buffer');

				var firstSha = git.GitUtil.blobShaHex(firstBuffer);
				assert.strictEqual(firstSha, expectedSha, 'firstSha vs expected');

				// get again, should be cached
				return repo.api.getBlob(expectedSha).progress((note:any) => {
					notes.push(note);
				}).then((second) => {
					assert.ok(second, 'second data');
					assert.isObject(second, 'second data');
					assert.strictEqual(second.sha, expectedSha, 'second.sha vs expectedSha');

					var secondBuffer = git.GitUtil.decodeBlobJson(first);
					assert.instanceOf(secondBuffer, Buffer, 'buffer');
					var secondSha = git.GitUtil.blobShaHex(secondBuffer);
					assert.strictEqual(secondSha, expectedSha, 'secondSha vs expected');

					helper.assertNotes(notes, [
						{
							message: /^remote: /,
							code: 'http 200'
						},
						{
							message: /^local: /,
							code: null
						}
					], 'second');
				});
			});