10 examples of 'jest mock imported function' in JavaScript

55
export function getModuleCreatorNewMock(module: BraintreeDataCollector): BraintreeModuleCreator {
56
    return {
57
        create: jest.fn(() => Promise.resolve({ ...module })),
58
    };
59
}

79
export function MockModule(module: ImportInstance): ImportInstance {
80
  let ngModule: Type;
81
  let ngModuleProviders: Provider[] | undefined;
82
  let moduleMockPointer: Type;
83
84
  if (isModuleWithProviders(module)) {
85
    ngModule = module.ngModule;
86
    if (module.providers) {
87
      ngModuleProviders = module.providers;
88
    }
89
  } else {
90
    ngModule = module;
91
  }
92
93
  if (NEVER_MOCK.includes(ngModule)) {
94
    return module;
95
  }
96
97
  // Every module should be mocked only once to avoid errors like:
98
  // Failed: Type ...Component is part of the declarations of 2 modules: ...Module and ...Module...
99
  const cacheHit = cache.get(ngModule);
100
  if (cacheHit) {
101
    moduleMockPointer = cacheHit;
102
  } else {
103
    @NgModule(MockIt(ngModule))
104
    @MockOf(ngModule)
105
    class ModuleMock {
106
    }
107
108
    moduleMockPointer = ModuleMock;
109
    cache.set(ngModule, moduleMockPointer);
110
  }
111
112
  if (ngModuleProviders) {
113
    return {
114
      ngModule: moduleMockPointer,
115
      providers: flatten(ngModuleProviders).map(mockProvider)
116
        .filter((provider) => !!provider) as Provider[],
117
    };
118
  }
119
  return moduleMockPointer;
120
}

13
SourceGroupsManager: jest.fn().mockImplementation(function mock() {
14
  this.setImportStatus = jest.fn();
15
  this.findByImportId = jest.fn();
16
}),

4
getSpy() {
5
  return jest.fn();
6
}

732
function mock(implementation) {
733
	mockImplementation = implementation;
734
	return api;
735
}

239
function partiallInjectMethod(owner, mockName, fn, $injector) {
240
  la(check.unemptyString(mockName), 'expected mock name', mockName);
241
  la(check.fn(fn), 'expected function for', mockName, 'got', fn);
242
243
  var diNames = $injector.annotate(fn);
244
  log('dinames for', mockName, diNames);
245
  mockInjects.push.apply(mockInjects, diNames);
246
247
  var wrappedFunction = function injectedDependenciesIntoMockFunction() {
248
    var runtimeArguments = arguments;
249
    var k = 0;
250
    var args = diNames.map(function (name) {
251
      if (check.has(dependencies, name)) {
252
        // name is injected by dependency injection
253
        return dependencies[name];
254
      }
255
      // argument is runtime
256
      return runtimeArguments[k++];
257
    });
258
    return fn.apply(owner, args);
259
  };
260
  return wrappedFunction;
261
}

24
function mockRequire(relative){
25
  var relativeRequire = requireLike(relative);
26
27
  return function(module){
28
    return mocks[module] || relativeRequire(module);
29
  };
30
}

33
_jestGetType = function _jestGetType() {
34
  return data;
35
};

79
function transformJestCall(context, call) {
80
  if (!t.isMemberExpression(call.callee)) {
81
    return undefined;
82
  }
83
  var object;
84
  var member = call.callee;
85
  if (t.isIdentifier(member.object, {name: 'jest'})) {
86
    object = member.object;
87
  } else if (t.isCallExpression(member.object)) {
88
    object = transformJestCall(context, member.object);
89
  }
90
  if (!object) {
91
    return undefined;
92
  }
93
  var args = call.arguments.slice();
94
  if (
95
    args[0] &&
96
    args[0].type === 'Literal' &&
97
    isJestProperty(t, member.property)
98
  ) {
99
    var module = mapModule(context, args[0].value);
100
    if (module) {
101
      args[0] = t.literal(module);
102
    }
103
  }
104
  return t.callExpression(
105
    t.memberExpression(object, member.property),
106
    args
107
  );
108
}

15
function moduleFunction1(globalProp2: any, moduleProp1: any) {
16
    // ! shadow !
17
    setTimeout(moduleProp1, 5); // should fail
18
    setTimeout(moduleProp2, 5); // should pass
19
    setTimeout(globalFunction1, 5); // should fail
20
    setTimeout(globalProp2, 5); // should fail
21
}