为遗留 Node.js 后端编写自动化测试

给定由不同数量的用户发布的曲目列表
当访问者访问“热门曲目”页面时
那么以受欢迎程度降序排列曲目


给定两首相同配乐的歌曲
当用户转发其中一首歌曲时
那么这首歌就会登上“热门曲目”排行榜的榜首




给定两周前发布的两首歌曲，分数略有不同
分数最低的曲目会在1周后被转发
当分数被计算出来时
那么在“热门曲目”页面，显示被转发曲目的排名“上升”

describe("Hot Tracks", () => {
  it("displays the tracks in descending order of popularity", async () => {
    const regularTrack = { popularityScore: 1 };
    const popularTrack = { popularityScore: 2 };
    storeTracks([ regularTrack, popularTrack ]);
    expect(await getHotTracks()).toMatchObject([ popularTrack, regularTrack ]);
  });
});

const mongodb = require('./mongodb.js');



const fetchRankedTracks = (params) =>
  mongodb.tracks
    .find({}, { sort: [['score', 'desc']], ...params })
    .toArray();

exports.getHotTracks = async function (params = {}) {
  const tracks = await fetchRankedTracks(params);
  const pidList = snip.objArrayToValueArray(tracks, 'pId');
  const posts = await fetchPostsByPid(pidList);
  return tracks.map((track, i) => {
    const post = posts.find(({ eId }) => eId === track.eId);
    return computeTrend(post ? mergePostData(track, post) : track);
  });
};

jest.mock("mongodb.js", {
  tracks: {
    find: (queryObj, { sort }) => ({
      toArray: () => ([
        { name: 'track1', score: 1 },
        { name: 'track2', score: 2 },
      ]),
    }),
  },
});

async function compareGenres(genre1, genre2) {
  const tracks1 = await mongodb.tracks.find({ genre: genre1 }).toArray();
  const tracks1 = await mongodb.tracks.find({ genre: genre2 }).toArray();
  // [...]
}

jest.mock("mongodb", {
  tracks: {
    find: (queryObj, params) => ({
      toArray: () => {
        if (queryObj === 'rock') {
          return [
            { name: 'track1', score: 1 },
            { name: 'track2', score: 2 },
          ];
        } else if (queryObj === 'hip hop') {
          return [
            { name: 'track3', score: 1 },
            { name: 'track4', score: 2 },
          ];
        }
      },
    }),
  },
});

exports.getHotTracks = async function (
  fetchRankedTracks: () => Track[],
  fetchCorrespondingPosts: (tracks: Track[]) => Post[]
) {
    const tracks = await fetchRankedTracks();
    const posts = await fetchCorrespondingPosts(tracks);
    // [...]

// 注意:在运行这些测试之前，确保MongoDB和Openwhyd服务器正在运行。
describe("Hot Tracks (approval tests - to be replaced later by unit tests)", () => {
  beforeEach(async () => {
    await mongodb.clearDatabase();
  });


  it("renders ranked tracks", async () => {
    await mongodb.tracks.insertMany([
      { name: "a regular track", score: 1 },
      { name: "a popular track", score: 2 },
    ]);
    const serverURL = await startOpenwhydServer();
    const html = await httpClient.get(`${serverURL}/hot`);
    expect(html).toMatchSnapshot();
    //注意:上面的请求在"tracks"集合=>中做了改变，不需要快照该集合的状态。
  });


  it("updates the score of a track when it's reposted", async () => {
    const users = [
      { id: 0, name: "user 0", pwd: "123" },
      { id: 1, name: "user 1", pwd: "456" },
    ];
    await mongodb.users.insertMany(users);
    const serverURL = await startOpenwhydServer();
    const userSession = [
      await httpClient.post(`${serverURL}/api/login`, users[0]),
      await httpClient.post(`${serverURL}/api/login`, users[1]),
    ];
    const posts = [
      // user 0 posts track A
      await httpClient.post(
        `${serverURL}/api/post`,
        { action: "insert", eId: "track_A" },
        { cookies: userSession[0].cookies }
      ),
      // user 0 posts track B
      await httpClient.post(
        `${serverURL}/api/post`,
        { action: "insert", eId: "track_B" },
        { cookies: userSession[0].cookies }
      ), 
    ];
    // user 1 reposts track A
    await httpClient.post(
      `${serverURL}/api/post`,
      { action: "insert", pId: posts[0].pId },
      { cookies: userSession[1].cookies }
    );
    const ranking = await httpClient.get(`${serverURL}/hot?format=json`);
    expect(ranking).toMatchSnapshot();
    //注意:上面的请求更新"tracks"集合=>，我们也快照该集合的状态。
    const tracksCollection = await mongodb.tracks.find({}).toArray();
    expect(tracksCollection).toMatchSnapshot();
  });
});

 const { _id } = await httpClient.post(
      `${serverURL}/api/post`,
      { action: "insert", pId: posts[0].pId },
      { cookies: userSession[1].cookies }
    );
    const cleanJSON = (body) => body.replaceAll(_id, '__posted_track_id__');
    const ranking = await httpClient.get(`${serverURL}/hot?format=json`);
    expect(cleanJSON(ranking)).toMatchSnapshot();

describe('hot tracks feature', () => {
  it('should list one track in first position, if just that track was posted', () => {
    const postedTrack = { name: 'a good track' };
    expect(getHotTracks()).toMatchObject([ postedTrack ]);
  });
});

function getHotTracks() {
  return [{ name: 'a good track' }];
}

function getHotTracks(postedTracks) {
  // 按分数降序排序
  return postedTracks.sort((a, b) => b.score - a.score);
}


describe('hot tracks feature', () => {
  it('should list one track in first position, if just that track was posted', () => {
    const postedTrack = { name: 'a good track' };
    const postedTracks = [ postedTrack ];
    expect(getHotTracks(postedTracks)).toMatchObject([ postedTrack ]);
  });


  it('should list the track with higher score in first position, given two posted tracks with different scores', () => {
    const regularTrack = { name: 'a good track', score: 1 };
    const popularTrack = { name: 'a very good track', score: 2 };
    const postedTracks = [ regularTrack, popularTrack ];
    expect(getHotTracks(postedTracks)).toMatchObject([ popularTrack, regularTrack ]);
  });
});

function getHotTracks(getTracksByDescendingScore) {
  return getTracksByDescendingScore();
}


describe('hot tracks feature', () => {
  it('should list one track in first position, if just that track was posted', () => {
    const postedTrack = { name: 'a good track' };
    const getTracksByDescendingScore = () => [ postedTrack ];
    expect(getHotTracks(getTracksByDescendingScore)).toMatchObject([ postedTrack ]);
  });


  it('should list the track with higher score in first position, given two posted tracks with different scores', () => {
    const regularTrack = { name: 'a good track', score: 1 };
    const popularTrack = { name: 'a very good track', score: 2 };
    const getTracksByDescendingScore = () => [ regularTrack, popularTrack ];
    expect(getHotTracks(getTracksByDescendingScore)).toMatchObject([ popularTrack, regularTrack ]);
  });
});

exports.getHotTracksFromDb = async function (params = {}, handler) {
  const getTracksByDescendingScore = () => exports.fetchRankedTracks(params);
  const tracks = await getHotTracks(getTracksByDescendingScore);
  const pidList = snip.objArrayToValueArray(tracks, 'pId');
  const posts = await fetchPostsByPid(pidList);
  // complete track items with additional metadata (from posts)
  return tracks.map((track) => {
    const post = posts.find(({ eId }) => eId === track.eId);
    return computeTrend(post ? mergePostData(track, post) : track);
  });
}

it('should return tracks with post metadata', async () => {
  const posts = [
    {
      _id: '61e19a3f078b4c9934e72ce4',
      eId: '1',
      pl: { name: 'soundtrack of my life', id: 0 }, // metadata from the post that will be included in the list of hot tracks
    },
    {
      _id: '61e19a3f078b4c9934e72ce5',
      eId: '2',
      text: 'my favorite track ever!', // metadata from the post that will be included in the list of hot tracks
    },
  ];
  const getTracksByDescendingScore = () => [
    { eId: posts[0].eId, pId: posts[0]._id },
    { eId: posts[1].eId, pId: posts[1]._id },
  ];
  const fetchPostsByPid = (pidList) => posts.filter(({ _id }) => pidList.includes(_id));
  const hotTracks = await getHotTracks(getTracksByDescendingScore, fetchPostsByPid);
  expect(hotTracks[0].pl).toMatchObject(posts[0].pl);
  expect(hotTracks[1].text).toMatchObject(posts[1].text);
});

// 文件: app/features/hot-tracks.js
exports.getHotTracks = async function (getTracksByDescendingScore, fetchPostsByPid) {
  const tracks = await getTracksByDescendingScore();
  const pidList = snip.objArrayToValueArray(tracks, 'pId');
  const posts = await fetchPostsByPid(pidList);
  // complete track items with additional metadata (from posts)
  return tracks.map((track) => {
    const post = posts.find(({ eId }) => eId === track.eId);
    return computeTrend(post ? mergePostData(track, post) : track);
  });
};


// 文件: app/models/track.js
exports.getHotTracksFromDb = async function (params = {}, handler) {
  const getTracksByDescendingScore = () =>
    new Promise((resolve) => {
      exports.fetch(params, resolve);
    });
  return feature.getHotTracks(getTracksByDescendingScore, fetchPostsByPid);
};

it('should list one track in first position, if just that track was posted', async () => {
  const postedTrack = { name: 'a good track' };
  const getTracksByDescendingScore = () => [ postedTrack ];
  const fetchPostsByPid = () => [];
  expect(await getHotTracks(getTracksByDescendingScore, fetchPostsByPid))
    .toMatchObject([postedTrack]);
});


it('should list the track with higher score in first position, given two posted tracks with different scores', async () => {
  const regularTrack = { name: 'a good track', score: 1 };
  const popularTrack = { name: 'a very good track', score: 2 };
  const getTracksByDescendingScore = () => [ popularTrack, regularTrack ];
  const fetchPostsByPid = () => [];
  expect(await getHotTracks(getTracksByDescendingScore, fetchPostsByPid))
    .toMatchObject([ popularTrack, regularTrack ]);
});


it('should return tracks with post metadata', async () => {
  const posts = [
    {
      _id: '61e19a3f078b4c9934e72ce4',
      eId: '1',
      pl: { name: 'soundtrack of my life', id: 0 }, // metadata from the post that will be included in the list of hot tracks
    },
    {
      _id: '61e19a3f078b4c9934e72ce5',
      eId: '2',
      text: 'my favorite track ever!', // metadata from the post that will be included in the list of hot tracks
    },
  ];
  const getTracksByDescendingScore = () => [
    { eId: posts[0].eId, pId: posts[0]._id },
    { eId: posts[1].eId, pId: posts[1]._id },
  ];
  const fetchPostsByPid = (pidList) => posts.filter(({ _id }) => pidList.includes(_id));
  const hotTracks = await getHotTracks(getTracksByDescendingScore, fetchPostsByPid);
  expect(hotTracks[0].pl).toMatchObject(posts[0].pl);
  expect(hotTracks[1].text).toMatchObject(posts[1].text);
});