Jest.js 错误：“已接收：序列化为相同的字符串”

Question

我在这个测试中遇到了一个奇怪的问题：

交易.test.js

import Deal from "../src/models/Deal";
import apiProducts from "../__mocks__/api/products";

describe("Deal", () => {
  describe("Deal.fromApi", () => {
    it("takes an api product and returns a Deal", () => {
      const apiDeal = apiProducts[0];
      const newDeal = Deal.fromApi(apiDeal);
      const expected = expectedDeal();
      expect(newDeal).toEqual(expected);
    });
  });
});

交易.js

export default class Deal {
  // no constructor since we only ever create a deal from Deal.fromApi

  static fromApi(obj: Object): Deal {
    const deal = new Deal();
    deal.id = obj.id;
    deal.name = obj.name;
    deal.slug = obj.slug;
    deal.permalink = obj.permalink;
    deal.dateCreated = obj.date_created;
    deal.dateModified = obj.date_modified;
    deal.status = obj.status;
    deal.featured = obj.featured;
    deal.catalogVisibility = obj.catalog_visibility;
    deal.descriptionHTML = obj.description;
    deal.shortDescriptionHTML = obj.short_description;
    deal.price = Number(obj.price);
    deal.regularPrice = Number(obj.regular_price);
    deal.salePrice = Number(obj.sale_price);
    deal.dateOnSaleFrom = obj.date_on_sale_from;
    deal.dateOnSaleTo = obj.date_on_sale_to;
    deal.onSale = obj.on_sale;
    deal.purchasable = obj.purchasable;
    deal.relatedIds = obj.related_ids;
    deal.upsellIds = obj.upsell_ids;
    deal.crossSellIds = obj.cross_sell_ids;
    deal.categories = obj.categories;
    deal.tags = obj.tags;
    deal.images = obj.images;
    return deal;
  }

 descriptionWithTextSize(size: number): string {
    return this.descriptionWithStyle(`font-size:${size}`);
  }

  descriptionWithStyle(style: string): string {
    return `<div style="${style}">${this.description}</div>`;
  }

  distanceFromLocation = (
    location: Location,
    unit: unitOfDistance = "mi"
  ): number => {
    return distanceBetween(this.location, location);
  };

  distanceFrom = (otherDeal: Deal, unit: unitOfDistance = "mi"): number => {
    return distanceBetween(this.location, otherDeal.location);
  };

  static toApi(deal: Deal): Object {
    return { ...deal };
  }
}

测试失败并出现以下错误：

  ? Deal › Deal.fromApi › takes an api product and returns a Deal

    expect(received).toEqual(expected) // deep equality

    Expected: {"catalogVisibility": "visible", "categories": [{"id": 15, "name": "New York", "slug": "new-york"}], "crossSellIds": [34, 31], "dateCreated": "2019-05-18T17:36:14", "dateModified": "2019-05-18T17:39:02", "dateOnSaleFrom": null, "dateOnSaleTo": null, "descriptionHTML": "<p>Pete's Tavern<br />
    129 E 18th St<br />
    New York, NY 10003</p>
    <p>Weekdays from 4 p.m. to 7 p.m.<br />
    $5 wines and beers</p>
    ", "distanceFromLocation": [Function anonymous], "featured": false, "id": 566, "images": [{"alt": "", "date_created": "2019-05-18T17:38:52", "date_created_gmt": "2019-05-18T17:38:52", "date_modified": "2019-05-18T17:38:52", "date_modified_gmt": "2019-05-18T17:38:52", "id": 567, "name": "wine and beers2", "src": "https://tragodeals.com/wp-content/uploads/2019/05/wine-and-beers2.jpg"}], "name": "Wines and beers", "onSale": true, "permalink": "https://tragodeals.com/product/wines-and-beers/", "price": 5, "purchasable": true, "regularPrice": 11, "relatedIds": [552, 564, 390, 37, 543], "salePrice": 5, "shortDescriptionHTML": "<p>$5 wines and beers</p>
    ", "slug": "wines-and-beers", "status": "publish", "tags": [{"id": 58, "name": "beers", "slug": "beers"}, {"id": 54, "name": "Cocktails", "slug": "cocktails"}, {"id": 45, "name": "drink", "slug": "drink"}, {"id": 57, "name": "wine", "slug": "wine"}], "upsellIds": [53]}
    Received: serializes to the same string

    > 15 |       expect(newDeal).toEqual(expected);
         |                       ^
      16 |     });
      17 |   });
      18 | });

      at Object.toEqual (__tests__/deal.test.js:15:23)

我插入了这个循环来调查：

for (let key in expected) {
  expect(expected[key]).toEqual(newDeal[key]);
}

我看到问题出在函数上。所以我把整个测试改成了这样：

      for (let key in expected) {
        if (typeof expected[key] === "function") continue;
        expect(expected[key]).toEqual(newDeal[key]);
      }
     // expect(newDeal).toEqual(expected);

它通过了，也应该失败。（如果你阅读了这个问题的旧版本，我在那里通过了我不理解的测试，那是因为我return本应该在循环中进行continueing）。

但我希望能够使用标准 assertion 来做到这一点expect(newDeal).toEqual(expected)。看起来我对检查类对象 ( Deal) 与函数的相等性有一些不理解。

附注。您可能会建议使用toMatchObject. 但是，遗憾的是：

  ? Deal › Deal.fromApi › takes an api product and returns a Deal

    expect(received).toMatchObject(expected)

    - Expected
    + Received

    @@ -1,6 +1,6 @@
    - Deal {
    + Object {
        "address": "129 E 18th St New York, NY 10003",
        "catalogVisibility": "visible",
        "categories": Array [
          Object {
            "id": 15,

      13 |         expect(expected[key]).toEqual(newDeal[key]);
      14 |       }
    > 15 |       expect(newDeal).toMatchObject(expected);
         |                       ^
      16 |     });
      17 |   });
      18 | });

Answer 1

与其他同事类似，我在 Array 比较时遇到了这个问题，我基本上是在测试一个函数，该函数获得了数组中最大的字符串，此外，如果这些字符串中有 1 个以上与可能的最大长度匹配，它应该返回一个数组。

当我开始测试时，我收到以下消息：

所以我更换了toBe方法

expect(function(array1)).toBe('one result')

与toStrictEqual做了深刻的相等比较

expect(function(array2)).toStrictEqual(['more than one', 'more than one']);

Answer 2

在尝试比较数组时遇到了这个问题，其中一个数组中有一个索引集为 -1 的元素（想象一下要设置的任何其他键，除了从 0 到 N 的数字）。因此，您可能在以下场景中遇到此错误：

const arr = [1, 2]
arr[-1] = 'foo'
expect(arr).toEqual([1, 2])

它们都序列化为同一个字符串，但它们不相等。

Answer 3

我有一个类似的情况，对象有一个 base64 编码的字符串，我管理测试以使用以下方法比较对象的序列化JSON.stringify：

expect(JSON.stringify(newDeal)).toMatchObject(JSON.stringify(expected));

Answer 4

当我尝试比较数组时遇到了这个问题，其中一个数组从 Graphql 的解析器返回，另一个数组来自我的测试输入。
所有字段都是相同的，除了来自 Graphql 的数组内的条目没有任何字段，而__proto__我的测试输入中的条目有__proto__: Object，这会导致toStrictEqual失败，因为它除了检查结构之外还检查类型。所以，就我而言，该类型导致失败。更改它以toEqual解决问题。

                expect(res.data.myMutation.values).toEqual(
                    testInput.values,
                );

Answer 5

在我的情况下，我对代理对象和常规对象进行深度平等检查。

const proxyObject = new Proxy({}, {
    get: function(target, prop) {
        return Object.hasOwnProperty.call(target, prop) ? target[prop] : '';
    }
})
expect(proxyObject).toEqual({})
// Expected: {}
// Received: serializes to the same string

它应该是：

expect(proxyObject).toMatchObject({})

Answer 6

我在比较两个 MongoDb ObjectId 时遇到了类似的问题。为了克服这个问题，我使用了

expect(`${thisObject._id}`).toEqual(`${thatObject._id}`);