"use strict";
function Cow(lungCapacity) {
  let airInLungs = 0;
  function breathe() {
    airInLungs = lungCapacity;
  }
  function getAirInLungs() {
    return airInLungs;
  }
  function moo() {
    let output = "m";
    let air = getAirInLungs();
    while (air-- > 0) {
      // The 'goes to' operator.df
      output += "o";
    }
    airInLungs = air;
    return output;
  }
  return { breathe: breathe, moo: moo };
}
const herd = [];
for (var i = 0; i < 30000; i++) {
  const cow = Cow(i);
  cow.index = i;
  herd.push(cow);
}
console.log(process.memoryUsage());
const start = Date.now();
herd.map(function (cow) {
  cow.breathe();
  cow.moo();
});
console.log("Finished mooing in " + (Date.now() - start) / 1000 + " seconds");

"use strict";
function HttpClient(config) {
  return {
    get: function (path, callback) {
      // 이 함수의 로직은 중요하지 않습니다
      // 테스트를 위해서 mock 할 예정입니다
    },
  };
}
module.exports = HttpClient;

// foo_model.js
"use strict";
function FooModel(fooClient) {
  return {
    getById: function (fooId, callback) {
      return fooClient.get(`/foo/${fooId}`, (err, result) => {
        if (err) return callback(err);
        const foo = JSON.parse(result.body);
        return callback(null, foo);
      });
    },
  };
}
module.exports = FooModel;

// test.js
"use strict";
const sinon = require("sinon");
const FooModel = require("./foo_model");
describe("Foo", () => {
  describe("#getById", () => {
    describe("when fooId is 10", () => {
      let mockFooClient;
      beforeEach(() => {
        mockFooClient = { get: sinon.spy() };
      });
      it("sends GET /foo/10 to the foo service", () => {
        // mock된 Client를 FooModel로 주입한다
        const fooModel = FooModel(mockFooClient);
        // 테스트 환경에서 호출
        fooModel.getById(10);
        // 실제로 원하는 형태로 호출되었는지 assert를 통해 확인한다.
        sinon.assert.calledWith(mockFooClient.get, "/foo/10");
      });
    });
  });
});

// foo_model.js
const HttpClient = require('./http_client')
function FooModel (config)
    // 테스트 코드에서 fooClient를 접근할 수 없음!
    const fooClient = HttpClient(config)
    return {
        getById: function (fooId, callback) {
            return fooClient.get(`/foo/${fooId}`, (err, result) => {
                if (err) return callback(err)
                const foo = JSON.parse(result.body)
                return callback(null, foo)
            })
        }
    }
}
module.exports = FooModel

"use strict";
const sinon = require("sinon");
describe("Foo", () => {
  describe("#getById", () => {
    describe("when fooId is 10", () => {
      let mockFooClient;
      beforeEach(() => {
        mockFooClient = { get: sinon.spy() };
      });
      let FooModel;
      beforeEach(() => {
        // 'foo_model'의 캐시가 이미 있는 상황에 대비해서
        // 캐시를 날려준다
        delete require.cache[require.resolve("./foo_model")];
        // 'http_client'가 캐시에 있게끔 해준다
        require("./http_client");
        // 우리의 mock으로 오버라이드 하기
        require.cache[require.resolve("./http_client")].exports = () =>
          mockFooClient;
        // foo_model을 다시 로드하면
        // 우리가 오버라이드한 캐시를 사용하게 됨
        FooModel = require("./foo_model");
      });
      it("sends GET /foo/10 to the foo service", () => {
        const fooModel = FooModel();
        fooModel.getById(10);
        sinon.assert.calledWith(mockFooClient.get, "/foo/10");
      });
    });
  });
});

// http_client.js
"use strict";
const request = require("request");
class HttpClient {
  constructor(config) {
    this.config = config;
  }
  get(path, callback) {
    // 여전히 원래 내용물은 중요하지 않음
    // mock 할 부분이기 때문에...
  }
}
module.exports = HttpClient;

// foo_model.js
// 이전 예제와 유일하게 차이점은, new 키워드를 사용한다는점 (HttpClient가 클래스니까)
"use strict";
const HttpClient = require("./http_client");
function FooModel(config) {
  const fooClient = new HttpClient(config);
  return {
    getById: function (fooId, callback) {
      return fooClient.get(`/foo/${fooId}`, (err, result) => {
        if (err) return callback(err);
        const foo = JSON.parse(result.body);
        return callback(null, foo);
      });
    },
  };
}

module.exports = FooModel;

//test.js
"use strict";
const sinon = require("sinon");
const FooModel = require("./foo_model");
const HttpClient = require("./http_client");
describe("Foo", () => {
  describe("#getById", () => {
    describe("when fooId is 10", () => {
      let mockFooClient;
      let $get;
      beforeEach(() => {
        $get = HttpClient.prototype.get;
        HttpClient.prototype.get = sinon.stub();
      });
      afterEach(() => {
        // 테스트 종료 후에 원래 형태로 돌려놓기
        HttpClient.prototype.get = $get;
      });
      it("sends GET /foo/10 to the foo service", () => {
        const fooModel = FooModel();
        fooModel.getById(10);
        sinon.assert.calledWith(HttpClient.prototype.get, "/foo/10");
      });
    });
  });
});