pulsar/spec/spec-helper.coffee

306 lines
11 KiB
CoffeeScript
Raw Normal View History

require 'jasmine-json'
2015-10-17 02:49:24 +03:00
require '../src/window'
require '../vendor/jasmine-jquery'
path = require 'path'
2014-02-24 05:09:05 +04:00
_ = require 'underscore-plus'
fs = require 'fs-plus'
Grim = require 'grim'
2015-10-09 23:46:51 +03:00
pathwatcher = require 'pathwatcher'
FindParentDir = require 'find-parent-dir'
2014-09-23 01:35:13 +04:00
TextEditor = require '../src/text-editor'
TextEditorElement = require '../src/text-editor-element'
2013-09-18 05:58:41 +04:00
TokenizedBuffer = require '../src/tokenized-buffer'
clipboard = require '../src/safe-clipboard'
jasmineStyle = document.createElement('style')
jasmineStyle.textContent = atom.themes.loadStylesheet(atom.themes.resolveStylesheet('../static/jasmine'))
document.head.appendChild(jasmineStyle)
2013-09-18 01:54:33 +04:00
fixturePackagesPath = path.resolve(__dirname, './fixtures/packages')
atom.packages.packageDirPaths.unshift(fixturePackagesPath)
document.querySelector('html').style.overflow = 'auto'
document.body.style.overflow = 'auto'
2013-02-20 23:44:50 +04:00
Set.prototype.jasmineToString = ->
result = "Set {"
first = true
@forEach (element) ->
result += ", " unless first
result += element.toString()
first = false
result + "}"
Set.prototype.isEqual = (other) ->
if other instanceof Set
return false if @size isnt other.size
values = @values()
until (next = values.next()).done
return false unless other.has(next.value)
true
else
false
2013-02-20 23:44:50 +04:00
jasmine.getEnv().addEqualityTester(_.isEqual) # Use underscore's definition of equality for toEqual assertions
2014-06-18 21:04:07 +04:00
2015-04-16 10:15:46 +03:00
if process.env.CI
2014-07-07 21:14:38 +04:00
jasmine.getEnv().defaultTimeoutInterval = 60000
2014-06-18 21:04:07 +04:00
else
jasmine.getEnv().defaultTimeoutInterval = 5000
2013-02-20 23:44:50 +04:00
2016-09-26 20:52:13 +03:00
{testPaths} = atom.getLoadSettings()
if specPackagePath = FindParentDir.sync(testPaths[0], 'package.json')
packageMetadata = require(path.join(specPackagePath, 'package.json'))
specPackageName = packageMetadata.name
if specDirectory = FindParentDir.sync(testPaths[0], 'fixtures')
specProjectPath = path.join(specDirectory, 'fixtures')
else
specProjectPath = path.join(__dirname, 'fixtures')
2013-11-22 02:55:25 +04:00
beforeEach ->
atom.project.setPaths([specProjectPath])
window.resetTimeouts()
2014-12-30 10:52:16 +03:00
spyOn(_._, "now").andCallFake -> window.now
spyOn(Date, 'now').andCallFake(-> window.now)
2014-12-30 10:52:16 +03:00
spyOn(window, "setTimeout").andCallFake window.fakeSetTimeout
spyOn(window, "clearTimeout").andCallFake window.fakeClearTimeout
spy = spyOn(atom.packages, 'resolvePackagePath').andCallFake (packageName) ->
if specPackageName and packageName is specPackageName
resolvePackagePath(specPackagePath)
else
resolvePackagePath(packageName)
resolvePackagePath = _.bind(spy.originalValue, atom.packages)
2013-10-09 03:23:34 +04:00
# prevent specs from modifying Atom's menus
spyOn(atom.menu, 'sendToBrowserProcess')
# reset config before each spec
atom.config.set "core.destroyEmptyPanes", false
atom.config.set "editor.fontFamily", "Courier"
atom.config.set "editor.fontSize", 16
atom.config.set "editor.autoIndent", false
atom.config.set "core.disabledPackages", ["package-that-throws-an-exception",
"package-with-broken-package-json", "package-with-broken-keymap"]
2014-12-30 10:52:41 +03:00
advanceClock(1000)
window.setTimeout.reset()
2012-12-13 03:23:36 +04:00
# make editor display updates synchronous
TextEditorElement::setUpdatedSynchronously(true)
2014-02-19 22:01:56 +04:00
spyOn(pathwatcher.File.prototype, "detectResurrectionAfterDelay").andCallFake -> @detectResurrection()
2014-09-23 01:35:13 +04:00
spyOn(TextEditor.prototype, "shouldPromptToSave").andReturn false
# make tokenization synchronous
TokenizedBuffer.prototype.chunkSize = Infinity
spyOn(TokenizedBuffer.prototype, "tokenizeInBackground").andCallFake -> @tokenizeNextChunk()
clipboardContent = 'initial clipboard content'
spyOn(clipboard, 'writeText').andCallFake (text) -> clipboardContent = text
spyOn(clipboard, 'readText').andCallFake -> clipboardContent
addCustomMatchers(this)
afterEach ->
ensureNoDeprecatedFunctionCalls()
ensureNoDeprecatedStylesheets()
waitsForPromise ->
atom.reset()
runs ->
document.getElementById('jasmine-content').innerHTML = '' unless window.debugContent
warnIfLeakingPathSubscriptions()
waits(0) # yield to ui thread to make screen update more frequently
warnIfLeakingPathSubscriptions = ->
2013-04-07 12:18:08 +04:00
watchedPaths = pathwatcher.getWatchedPaths()
if watchedPaths.length > 0
console.error("WARNING: Leaking subscriptions for paths: " + watchedPaths.join(", "))
pathwatcher.closeAllWatchers()
ensureNoDeprecatedFunctionCalls = ->
deprecations = _.clone(Grim.getDeprecations())
Grim.clearDeprecations()
if deprecations.length > 0
originalPrepareStackTrace = Error.prepareStackTrace
Error.prepareStackTrace = (error, stack) ->
output = []
for deprecation in deprecations
2014-04-22 22:01:05 +04:00
output.push "#{deprecation.originName} is deprecated. #{deprecation.message}"
output.push _.multiplyString("-", output[output.length - 1].length)
for stack in deprecation.getStacks()
for {functionName, location} in stack
output.push "#{functionName} -- #{location}"
output.push ""
output.join("\n")
error = new Error("Deprecated function(s) #{deprecations.map(({originName}) -> originName).join ', '}) were called.")
error.stack
Error.prepareStackTrace = originalPrepareStackTrace
throw error
ensureNoDeprecatedStylesheets = ->
deprecations = _.clone(atom.styles.getDeprecations())
atom.styles.clearDeprecations()
for sourcePath, deprecation of deprecations
title =
if sourcePath isnt 'undefined'
"Deprecated stylesheet at '#{sourcePath}':"
else
"Deprecated stylesheet:"
throw new Error("#{title}\n#{deprecation.message}")
emitObject = jasmine.StringPrettyPrinter.prototype.emitObject
jasmine.StringPrettyPrinter.prototype.emitObject = (obj) ->
if obj.inspect
@append obj.inspect()
else
emitObject.call(this, obj)
2012-11-17 04:12:04 +04:00
jasmine.unspy = (object, methodName) ->
throw new Error("Not a spy") unless object[methodName].hasOwnProperty('originalValue')
2012-11-17 04:12:04 +04:00
object[methodName] = object[methodName].originalValue
2014-11-20 03:20:39 +03:00
jasmine.attachToDOM = (element) ->
jasmineContent = document.querySelector('#jasmine-content')
jasmineContent.appendChild(element) unless jasmineContent.contains(element)
grimDeprecationsSnapshot = null
stylesDeprecationsSnapshot = null
2014-11-26 00:51:56 +03:00
jasmine.snapshotDeprecations = ->
grimDeprecationsSnapshot = _.clone(Grim.deprecations)
stylesDeprecationsSnapshot = _.clone(atom.styles.deprecationsBySourcePath)
2014-11-26 00:51:56 +03:00
jasmine.restoreDeprecationsSnapshot = ->
Grim.deprecations = grimDeprecationsSnapshot
atom.styles.deprecationsBySourcePath = stylesDeprecationsSnapshot
2014-11-26 00:51:56 +03:00
jasmine.useRealClock = ->
jasmine.unspy(window, 'setTimeout')
jasmine.unspy(window, 'clearTimeout')
jasmine.unspy(_._, 'now')
jasmine.unspy(Date, 'now')
# The clock is halfway mocked now in a sad and terrible way... only setTimeout
# and clearTimeout are included. This method will also include setInterval. We
# would do this everywhere if didn't cause us to break a bunch of package tests.
jasmine.useMockClock = ->
spyOn(window, 'setInterval').andCallFake(fakeSetInterval)
spyOn(window, 'clearInterval').andCallFake(fakeClearInterval)
addCustomMatchers = (spec) ->
spec.addMatchers
toBeInstanceOf: (expected) ->
beOrNotBe = if @isNot then "not be" else "be"
this.message = => "Expected #{jasmine.pp(@actual)} to #{beOrNotBe} instance of #{expected.name} class"
@actual instanceof expected
toHaveLength: (expected) ->
if not @actual?
this.message = => "Expected object #{@actual} has no length method"
false
else
haveOrNotHave = if @isNot then "not have" else "have"
this.message = => "Expected object with length #{@actual.length} to #{haveOrNotHave} length #{expected}"
2015-04-07 06:45:02 +03:00
@actual.length is expected
toExistOnDisk: (expected) ->
toOrNotTo = this.isNot and "not to" or "to"
@message = -> return "Expected path '#{@actual}' #{toOrNotTo} exist."
2013-11-01 00:43:44 +04:00
fs.existsSync(@actual)
2014-02-05 01:06:47 +04:00
toHaveFocus: ->
toOrNotTo = this.isNot and "not to" or "to"
2014-02-05 01:06:47 +04:00
if not document.hasFocus()
console.error "Specs will fail because the Dev Tools have focus. To fix this close the Dev Tools or click the spec runner."
@message = -> return "Expected element '#{@actual}' or its descendants #{toOrNotTo} have focus."
2014-02-05 01:06:47 +04:00
element = @actual
element = element.get(0) if element.jquery
element is document.activeElement or element.contains(document.activeElement)
2014-02-05 01:06:47 +04:00
2014-08-14 00:41:56 +04:00
toShow: ->
toOrNotTo = this.isNot and "not to" or "to"
2014-08-14 00:41:56 +04:00
element = @actual
element = element.get(0) if element.jquery
@message = -> return "Expected element '#{element}' or its descendants #{toOrNotTo} show."
2014-08-14 00:41:56 +04:00
element.style.display in ['block', 'inline-block', 'static', 'fixed']
toEqualPath: (expected) ->
actualPath = path.normalize(@actual)
expectedPath = path.normalize(expected)
@message = -> return "Expected path '#{actualPath}' to be equal to '#{expectedPath}'."
actualPath is expectedPath
window.waitsForPromise = (args...) ->
2016-01-15 05:17:29 +03:00
label = null
if args.length > 1
{shouldReject, timeout, label} = args[0]
else
shouldReject = false
2016-01-15 05:17:29 +03:00
label ?= 'promise to be resolved or rejected'
fn = _.last(args)
window.waitsFor label, timeout, (moveOn) ->
promise = fn()
if shouldReject
promise.catch.call(promise, moveOn)
promise.then ->
jasmine.getEnv().currentSpec.fail("Expected promise to be rejected, but it was resolved")
moveOn()
else
promise.then(moveOn)
promise.catch.call promise, (error) ->
2015-05-08 21:16:19 +03:00
jasmine.getEnv().currentSpec.fail("Expected promise to be resolved, but it was rejected with: #{error?.message} #{jasmine.pp(error)}")
moveOn()
window.resetTimeouts = ->
window.now = 0
window.timeoutCount = 0
2014-05-21 00:03:44 +04:00
window.intervalCount = 0
window.timeouts = []
2014-05-21 00:03:44 +04:00
window.intervalTimeouts = {}
window.fakeSetTimeout = (callback, ms=0) ->
id = ++window.timeoutCount
window.timeouts.push([id, window.now + ms, callback])
id
window.fakeClearTimeout = (idToClear) ->
2015-04-07 06:45:02 +03:00
window.timeouts = window.timeouts.filter ([id]) -> id isnt idToClear
window.fakeSetInterval = (callback, ms) ->
2014-05-21 00:03:44 +04:00
id = ++window.intervalCount
action = ->
callback()
2014-05-21 00:03:44 +04:00
window.intervalTimeouts[id] = window.fakeSetTimeout(action, ms)
window.intervalTimeouts[id] = window.fakeSetTimeout(action, ms)
id
window.fakeClearInterval = (idToClear) ->
2014-05-21 00:03:44 +04:00
window.fakeClearTimeout(@intervalTimeouts[idToClear])
window.advanceClock = (delta=1) ->
window.now += delta
callbacks = []
window.timeouts = window.timeouts.filter ([id, strikeTime, callback]) ->
if strikeTime <= window.now
callbacks.push(callback)
false
else
true
callback() for callback in callbacks
exports.mockLocalStorage = ->
items = {}
spyOn(global.localStorage, 'setItem').andCallFake (key, item) -> items[key] = item.toString(); undefined
spyOn(global.localStorage, 'getItem').andCallFake (key) -> items[key] ? null
spyOn(global.localStorage, 'removeItem').andCallFake (key) -> delete items[key]; undefined