How to use proxyquire - 10 common examples

const generateQuery = require('../../../query/address_search_using_ids');
const _ = require('lodash');
const proxyquire = require('proxyquire').noCallThru();
const mock_logger = require('pelias-mock-logger');
const MockQuery = require('./MockQuery');

module.exports.tests = {};

module.exports.tests.interface = (test, common) => {
  test('valid interface', (t) => {
    t.ok(_.isFunction(generateQuery));
    t.end();
  });
};

// helper for canned views
const views = {
  focus_only_function: () => 'focus_only_function',
  boundary_country: 'boundary_country view',

/* eslint-env mocha */

"use strict";

var assert = require("chai").assert;
var speedomatic = require("speedomatic");
var proxyquire = require("proxyquire").noPreserveCache();

describe("create-market/get-market-creation-cost", function () {
  var test = function (t) {
    it(t.description, function (done) {
      var getMarketCreationCost = proxyquire("../../../src/create-market/get-market-creation-cost", {
        "../api": t.stub.api,
      });
      getMarketCreationCost(t.params, function (err, marketCreationCost) {
        t.assertions(err, marketCreationCost);
        done();
      });
    });
  };
  test({
    description: "happy path",
    params: {

/* eslint-env mocha */

"use strict";

var assert = require("chai").assert;
var proxyquire = require("proxyquire").noPreserveCache();

var callcount = 0;

describe("trading/order-book/get-order-book-chunked", function () {
  var test = function (t) {
    it(t.description, function () {
      callcount = 0;
      var getOrderBookChunked = proxyquire("../../../../src/trading/order-book/get-order-book-chunked", {
        "./get-order-book": t.stub.getOrderBook,
        "../../api": function () {
          return {
            Orders: {
              getWorseOrderId: t.stub.api.Orders.getWorseOrderId
            }
          };
        }

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

'use strict';

const { assert } = require('chai');
const proxyquire = require('proxyquire').noPreserveCache();
const sinon = require('sinon');

describe('userAgent, mocked dependency', () => {
  let uaParser, userAgent, parserResult;

  beforeEach(() => {
    uaParser = {
      parse: sinon.spy(() => parserResult)
    };

    userAgent = proxyquire('../../lib/userAgent', {
      'node-uap': uaParser
    });
  });

  it(

import * as Proxyquire from "proxyquire";
import {Store} from "@tsed/core";
import {descriptorOf} from "@tsed/core";
import {AuthenticatedMiddleware} from "../../../../../packages/common/src/mvc/components/AuthenticatedMiddleware";
import {expect} from "chai";
import * as Sinon from "sinon";

const middleware: any = Sinon.stub();
// tslint:disable-next-line: variable-name
const UseBefore: any = Sinon.stub().returns(middleware);

const {Authenticated} = Proxyquire.load("../../../../../packages/common/src/mvc/decorators/method/authenticated", {
  "./useBefore": {UseBefore}
});

class Test {
  test() {}
}

describe("Authenticated", () => {
  before(() => {
    this.descriptor = {};
    this.options = {options: "options"};

    Authenticated(this.options)(Test, "test", descriptorOf(Test, "test"));
    this.store = Store.fromMethod(Test, "test");
  });

import {assert} from "chai";
import * as Sinon from "sinon";
import * as Proxyquire from "proxyquire";

const middleware: any = Sinon.stub();
// tslint:disable-next-line: variable-name
const Use: any = Sinon.stub().returns(middleware);

const {All, Get, Post, Put, Delete, Head, Patch} = Proxyquire.load("../../../../../packages/common/src/mvc/decorators/method/route", {
  "./use": {Use}
});

describe("Route decorators", () => {
  describe("All", () => {
    before(() => {
      this.options = ["/", () => {}];
      All(...this.options);
    });

    after(() => {
      delete this.descriptor;
      delete this.options;
    });

    it("should create middleware", () => {

import test from 'ava';
import { jsdom } from 'jsdom';
import sinon from 'sinon';
import proxy from 'proxyquire';
import camelcase from 'camelcase';

const sandbox = sinon.sandbox.create();
const castStub = sandbox.stub().returnsArg(0);
const camelSpy = sandbox.spy(camelcase);

proxy.noCallThru();
const metaProps = proxy('../src', {
    camelcase: camelSpy,
    './cast': castStub,
}).default;
proxy.callThru();

const doc = jsdom();
global.document = doc;

sandbox.spy(doc.head, 'querySelectorAll');
sandbox.stub(console, 'warn');

test.beforeEach(() => {
    sandbox.reset();
    doc.head.innerHTML = ''; // reset meta tags
});

test('no props returns empty object', (t) => {
    t.deepEqual(metaProps(), {});
});

'use strict'

// Tests for `.replyWithFile()`.

const path = require('path')
const { expect } = require('chai')
const proxyquire = require('proxyquire').preserveCache()
const nock = require('..')
const got = require('./got_client')

require('./setup')

const textFile = path.join(__dirname, '..', 'assets', 'reply_file_1.txt')
const binaryFile = path.join(__dirname, '..', 'assets', 'reply_file_2.txt.gz')

describe('`.replyWithFile()', () => {
  it('reply with file', async () => {
    const scope = nock('http://example.test')
      .get('/')
      .replyWithFile(200, textFile)

    const { statusCode, body } = await got('http://example.test/')

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const assert = require("chai").assert,
    path = require("path"),
    sinon = require("sinon"),
    leche = require("leche"),
    shell = require("shelljs"),
    Config = require("../../lib/config"),
    fs = require("fs"),
    os = require("os"),
    hash = require("../../lib/util/hash");

const proxyquire = require("proxyquire").noCallThru().noPreserveCache();

//------------------------------------------------------------------------------
// Tests
//------------------------------------------------------------------------------

describe("CLIEngine", () => {

    const examplePluginName = "eslint-plugin-example",
        examplePluginNameWithNamespace = "@eslint/eslint-plugin-example",
        requireStubs = {},
        examplePlugin = {
            rules: {
                "example-rule": require("../fixtures/rules/custom-rule"),
                "make-syntax-error": require("../fixtures/rules/make-syntax-error-rule")
            }
        },

var test = require('tape');
var proxyquire = require('proxyquire');
var sinon = require('sinon');

// proxyquired connection module
var Connection = proxyquire.noCallThru().load('../lib/connection',
  { serialport: {
    list: function() { return Promise.resolve(
      [
        { comName: '/dev/cu.sierravsp', manufacturer: '', serialNumber: '',
          pnpId: '', locationId: '', vendorId: '', productId: '' },
        { comName: '/dev/cu.Bluetooth-Incoming-Port', manufacturer: '',
          serialNumber: '', pnpId: '', locationId: '', vendorId: '',
          productId: '' },
        { comName: '/dev/cu.usbmodem1421', manufacturer: 'Arduino (www.arduino.cc)',
          serialNumber: '55432333038351F03170', pnpId: '', locationId: '0x14200000',
          vendorId: '0x2341', productId: '0x0043' }
      ])
    }
  },

  SerialPort: require('./helpers/mockSerial').SerialPort