beforeEach(function() {
response = new RedirectResponse('test');
$response.end = spy();
$response.setHeader = spy();
response.response = $response;
});
beforeEach(function() {
response = new BaseResponse();
response.response = {
setHeader: setHeaderSpy = spy(),
write: writeSpy = spy(),
$headers: {
test: 'test'
}
};
});
describe('js.event-target', () => {
let eventTarget;
const callbackA = simpleMock.spy(() => {});
beforeEach(() => {
eventTarget = new EventTarget();
});
afterEach(() => {
simpleMock.restore();
callbackA.reset();
});
it('Fires the correct callback', () => {
eventTarget.addEventListener('event-a', callbackA);
eventTarget.dispatchEvent({type: 'event-a'});
assert.equal(callbackA.callCount, 1);
});
it('Does not invoke a removed callback', () => {
eventTarget.addEventListener('event-a', callbackA);
eventTarget.removeEventListener('event-a', callbackA);
eventTarget.dispatchEvent({type: 'event-a'});
assert.equal(callbackA.callCount, 0);
});
});
beforeEach(function() {
writeHeadSpy = spy();
writeSpy = spy();
$request = {
headers: {
accept: 'text/html,'
},
path: 'test.html'
};
$response = {
test: 'test',
$responseContent: '',
writeHead: writeHeadSpy,
write: writeSpy
};
});
it('should call options.onProgress with a copy of status and return options', function () {
var onProgress = options.onProgress = simple.spy(Ember.K);
var result = sut.fireProgress(options);
assert(onProgress.called);
assert.notEqual(onProgress.lastCall.arg, options.status);
assert.deepEqual(onProgress.lastCall.arg, options.status);
assert.equal(result, options);
});
beforeEach(function() {
mock(fs, 'readdirSync', () => [ 'test' ]);
simple.mock(Promise, 'all');
spy = simple.spy();
app.configs = [
{
fn: spy
}
];
});
group.beforeEach(function (done) {
var serverMock
npmlogMock = {
http: simple.spy(),
error: simple.spy(),
silly: simple.spy(),
verbose: simple.spy(),
warn: simple.spy(),
levels: {
warn: 'warn'
}
}
serverMock = {
register: simple.spy()
}
require('../../../server/plugins/logger').register(serverMock)
var transformModule = serverMock.register.lastCall.arg.options.reporters.hoodieReporter[1].module
var TransformClass = proxyquire(transformModule, {
'npmlog': npmlogMock
})
// can also use with 'new', but just calling as a function so that line 9
// is also covered under test
logger = TransformClass()
done()
})
group.test('next callback', function (t) {
var eventMock = {
event: 'ops'
}
var transformCallback = simple.spy()
logger._transform(eventMock, 'utf8', transformCallback)
t.equals(transformCallback.callCount, 1, 'callback is called')
t.equals(transformCallback.lastCall.args[1], undefined, 'nothing is passed through transform')
t.end()
})
test('lib/get-api smoke', function (t) {
var storeSpy = simple.spy(function () {})
var state = {
store: storeSpy
}
var api = getApi(state, 'foo')
t.is(typeof api.start, 'function', 'api.start is a function')
t.is(storeSpy.callCount, 1, 'store() called once')
t.is(storeSpy.lastCall.arg, 'foo', 'store() called with passed type')
t.end()
})
it('test no asset template', function() {
let headMock,
unknownWriteSpy = spy();
$$templateLoaderMock.returnWith(false);
mock(UnknownResponse.prototype, 'constructor', noop);
headMock = mock(
UnknownResponse.prototype,
'head',
() => ({ write: unknownWriteSpy })
);
response.write();
assert(headMock.called);
assert(unknownWriteSpy.called);
});
beforeEach(function () {
emailAddress = '*****@*****.**';
onProgress = simple.spy(Ember.K);
findUpdates = simple.mock(sut, 'findUpdates').callFn(function () {
options = arguments[0];
options.updates = makeUpdates(5).toArray();
options.status.max = options.updates.length;
return RSVP.resolve(options);
});
processUpdates = simple.mock(sut, 'processUpdates').callFn(function () {
options = arguments[0];
return RSVP.resolve(options);
});
});
beforeEach(function () {
data = {internet_telegram$: '*****@*****.**'};
emailAddress = '*****@*****.**';
onProgress = simple.spy(Ember.K);
encodePayload = simple.mock(sut, 'encodePayload').callFn(function () {
options = arguments[0];
return RSVP.resolve(options);
});
loadContacts = simple.mock(sut, 'loadContacts').callFn(function () {
options = arguments[0];
options.contacts = makeContacts(3).toArray();
options.status.max = options.contacts.length;
return RSVP.resolve(options);
});
processContacts = simple.mock(sut, 'processContacts').callFn(function () {
options = arguments[0];
return RSVP.resolve(options);
});
});
beforeEach(function() {
$response = new $Response({
setHeader: spy()
});
});