spincycle
Version:
A reactive message router and object manager that lets clients subscribe to object property changes on the server
598 lines (521 loc) • 20.5 kB
HTML
<!--
@license
Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
-->
<html>
<head>
<meta charset="UTF-8">
<title>iron-dropdown basic tests</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0">
<script src="../../webcomponentsjs/webcomponents-lite.js"></script>
<script src="../../web-component-tester/browser.js"></script>
<script src="../../test-fixture/test-fixture-mocha.js"></script>
<script src="../../iron-test-helpers/mock-interactions.js"></script>
<link rel="import" href="../iron-dropdown.html">
<link rel="import" href="../../test-fixture/test-fixture.html">
</head>
<style>
body {
margin: 0;
padding: 0;
}
.container {
display: block;
position: relative;
width: 100px;
height: 100px;
background-color: yellow;
}
.positioned {
position: absolute;
top: 40px;
left: 40px;
}
.dropdown-content {
width: 50px;
height: 50px;
background-color: orange;
}
.big {
width: 3000px;
height: 3000px;
}
</style>
<body>
<test-fixture id="TrivialDropdown">
<template>
<iron-dropdown>
<div class="dropdown-content"></div>
</iron-dropdown>
</template>
</test-fixture>
<test-fixture id="NonLockingDropdown">
<template>
<iron-dropdown allow-outside-scroll>
<div class="dropdown-content">I don't lock scroll!</div>
</iron-dropdown>
</template>
</test-fixture>
<test-fixture id="AlignedDropdown">
<template>
<div class="container">
<iron-dropdown horizontal-align="right" vertical-align="top">
<div class="dropdown-content big"></div>
</iron-dropdown>
</div>
</template>
</test-fixture>
<!-- Absolutely position the dropdown so that it has enough space to move around -->
<test-fixture id="OffsetDropdownTopLeft">
<template>
<div class="container positioned">
<iron-dropdown>
<div class="dropdown-content"></div>
</iron-dropdown>
</div>
</template>
</test-fixture>
<test-fixture id="OffsetDropdownBottomRight">
<template>
<div class="container positioned">
<iron-dropdown horizontal-align="right" vertical-align="bottom">
<div class="dropdown-content"></div>
</iron-dropdown>
</div>
</template>
</test-fixture>
<test-fixture id="FocusableContentDropdown">
<template>
<iron-dropdown>
<div class="dropdown-content" tabindex="0">
<div class="subcontent" tabindex="0"></div>
</div>
</iron-dropdown>
</template>
</test-fixture>
<test-fixture id="RTLDropdownLeft">
<template>
<div dir="rtl" class="container">
<iron-dropdown>
<div class="dropdown-content"></div>
</iron-dropdown>
</div>
</template>
</test-fixture>
<test-fixture id="RTLDropdownRight">
<template>
<div dir="rtl" class="container">
<iron-dropdown horizontal-align="right">
<div class="dropdown-content"></div>
</iron-dropdown>
</div>
</template>
</test-fixture>
<test-fixture id="sizingTarget">
<template>
<iron-dropdown>
<div class="dropdown-content">
<div class="subcontent"></div>
</div>
</iron-dropdown>
</template>
</test-fixture>
<test-fixture id="EmptyDropdown">
<template>
<iron-dropdown></iron-dropdown>
</template>
</test-fixture>
<script>
function elementIsVisible(element) {
var contentRect = element.getBoundingClientRect();
var computedStyle = window.getComputedStyle(element);
return computedStyle.display !== 'none' &&
contentRect.width > 0 &&
contentRect.height > 0;
}
function runAfterOpen(overlay, callback) {
overlay.addEventListener('iron-overlay-opened', callback);
overlay.open();
}
function fireWheel(node, deltaX, deltaY) {
// IE 11 doesn't support WheelEvent, use CustomEvent.
var event = new CustomEvent('wheel', {
cancelable: true,
bubbles: true
});
event.deltaX = deltaX;
event.deltaY = deltaY;
node.dispatchEvent(event);
return event;
}
function dispatchScroll(target, scrollLeft, scrollTop) {
target.scrollLeft = scrollLeft;
target.scrollTop = scrollTop;
target.dispatchEvent(new CustomEvent('scroll', { bubbles:true } ));
}
suite('<iron-dropdown>', function() {
var dropdown;
var content;
suite('basic', function() {
setup(function() {
dropdown = fixture('TrivialDropdown');
content = Polymer.dom(dropdown).querySelector('.dropdown-content');
});
test('effectively hides the dropdown content', function() {
expect(elementIsVisible(content)).to.be.equal(false);
});
test('shows dropdown content when opened', function(done) {
runAfterOpen(dropdown, function() {
expect(elementIsVisible(content)).to.be.equal(true);
done();
});
});
test('hides dropdown content when outside is clicked', function(done) {
runAfterOpen(dropdown, function() {
expect(elementIsVisible(content)).to.be.equal(true);
dropdown.addEventListener('iron-overlay-closed', function() {
expect(elementIsVisible(content)).to.be.equal(false);
done();
});
MockInteractions.tap(dropdown.parentNode);
});
});
suite('when content is focusable', function() {
setup(function() {
dropdown = fixture('FocusableContentDropdown');
content = Polymer.dom(dropdown).querySelector('.dropdown-content');
});
test('focuses the content when opened', function(done) {
runAfterOpen(dropdown, function() {
expect(document.activeElement).to.be.equal(content);
done();
});
});
test('focuses a configured focus target', function(done) {
var focusableChild = Polymer.dom(content).querySelector('div[tabindex]');
dropdown.focusTarget = focusableChild;
runAfterOpen(dropdown, function() {
expect(document.activeElement).to.not.be.equal(content);
expect(document.activeElement).to.be.equal(focusableChild);
done();
});
});
});
suite('when dropdown is empty', function() {
test('keeps the sizingTarget default value', function() {
dropdown = fixture('EmptyDropdown');
expect(dropdown.sizingTarget).to.be.equal(dropdown);
});
});
suite('correct animationConfig setup', function() {
test('as objects', function() {
dropdown.openAnimationConfig = {
name: 'open-animation'
};
dropdown.closeAnimationConfig = {
name: 'close-animation'
};
dropdown.opened = true;
assert.deepEqual(dropdown.openAnimationConfig, {
name: 'open-animation',
node: content
}, 'open animation ok');
assert.deepEqual(dropdown.closeAnimationConfig, {
name: 'close-animation',
node: content
}, 'close animation ok');
assert.deepEqual(dropdown.animationConfig, {
open: dropdown.openAnimationConfig,
close: dropdown.closeAnimationConfig
}, 'animationConfig ok');
});
test('as arrays', function() {
dropdown.openAnimationConfig = [{
name: 'open-animation-1'
}, {
name: 'open-animation-2'
}];
dropdown.closeAnimationConfig = [{
name: 'close-animation-1'
}, {
name: 'close-animation-2'
}];
dropdown.opened = true;
assert.deepEqual(dropdown.openAnimationConfig, [{
name: 'open-animation-1',
node: content
}, {
name: 'open-animation-2',
node: content
}], 'open animation ok');
assert.deepEqual(dropdown.closeAnimationConfig, [{
name: 'close-animation-1',
node: content
}, {
name: 'close-animation-2',
node: content
}], 'close animation ok');
assert.deepEqual(dropdown.animationConfig, {
open: dropdown.openAnimationConfig,
close: dropdown.closeAnimationConfig
}, 'animationConfig ok');
});
});
});
suite('locking scroll', function() {
var bigDiv, scrollTarget;
suiteSetup(function() {
bigDiv = document.createElement('div');
bigDiv.classList.add('big');
document.body.appendChild(bigDiv);
// Need to discover if html or body is scrollable.
// Here we are sure the page is scrollable.
document.documentElement.scrollTop = 1;
if (document.documentElement.scrollTop === 1) {
document.documentElement.scrollTop = 0;
scrollTarget = document.documentElement;
} else {
scrollTarget = document.body;
}
});
suiteTeardown(function() {
document.body.removeChild(bigDiv);
});
setup(function() {
dropdown = fixture('TrivialDropdown');
});
teardown(function() {
dispatchScroll(scrollTarget, 0, 0);
});
test('should lock, only once', function(done) {
var openCount = 0;
runAfterOpen(dropdown, function() {
expect(Polymer.IronDropdownScrollManager._lockingElements.length)
.to.be.equal(1);
expect(Polymer.IronDropdownScrollManager.elementIsScrollLocked(document.body))
.to.be.equal(true);
expect(fireWheel(document.body, 0, 10).defaultPrevented).to.be.equal(true);
if (openCount === 0) {
// This triggers a second `pushScrollLock` with the same element, however
// that should not add the element to the `_lockingElements` stack twice
dropdown.close();
dropdown.open();
} else {
done();
}
openCount++;
});
});
test('should lock scroll', function(done) {
runAfterOpen(dropdown, function() {
dispatchScroll(scrollTarget, 10, 10);
assert.equal(scrollTarget.scrollTop, 0, 'scrollTop ok');
assert.equal(scrollTarget.scrollLeft, 0, 'scrollLeft ok');
done();
});
});
test('can be disabled with `allowOutsideScroll`', function(done) {
dropdown.allowOutsideScroll = true;
runAfterOpen(dropdown, function() {
dispatchScroll(scrollTarget, 10, 10);
assert.equal(scrollTarget.scrollTop, 10, 'scrollTop ok');
assert.equal(scrollTarget.scrollLeft, 10, 'scrollLeft ok');
done();
});
});
});
suite('non locking scroll', function() {
setup(function() {
dropdown = fixture('NonLockingDropdown');
});
test('can be disabled with `allowOutsideScroll`', function(done) {
runAfterOpen(dropdown, function() {
expect(Polymer.IronDropdownScrollManager.elementIsScrollLocked(document.body))
.to.be.equal(false);
expect(fireWheel(document.body, 0, 10).defaultPrevented).to.be.equal(false);
done();
});
});
});
suite('aligned dropdown', function() {
var parent;
var parentRect;
var dropdownRect;
setup(function() {
parent = fixture('AlignedDropdown');
dropdown = parent.querySelector('iron-dropdown');
parentRect = parent.getBoundingClientRect();
});
test('can be re-aligned to the right and the top', function(done) {
runAfterOpen(dropdown, function() {
dropdownRect = dropdown.getBoundingClientRect();
assert.equal(dropdownRect.top, parentRect.top, 'top ok');
assert.equal(dropdownRect.left, 0, 'left ok');
assert.equal(dropdownRect.bottom, window.innerHeight, 'bottom ok');
assert.equal(dropdownRect.right, parentRect.right, 'right ok');
done();
});
});
test('can be re-aligned to the bottom', function(done) {
dropdown.verticalAlign = 'bottom';
runAfterOpen(dropdown, function() {
dropdownRect = dropdown.getBoundingClientRect();
assert.equal(dropdownRect.top, 0, 'top ok');
assert.equal(dropdownRect.left, 0, 'left ok');
assert.equal(dropdownRect.bottom, parentRect.bottom, 'bottom ok');
assert.equal(dropdownRect.right, parentRect.right, 'right ok');
done();
});
});
test('handles parent\'s stacking context', function(done) {
// This will create a new stacking context.
parent.style.transform = 'translateZ(0)';
runAfterOpen(dropdown, function() {
dropdownRect = dropdown.getBoundingClientRect();
assert.equal(dropdownRect.top, parentRect.top, 'top ok');
assert.equal(dropdownRect.left, 0, 'left ok');
assert.equal(dropdownRect.bottom, window.innerHeight, 'bottom ok');
assert.equal(dropdownRect.right, parentRect.right, 'right ok');
done();
});
});
});
suite('when align is left/top, with an offset', function() {
var dropdownRect;
var offsetDropdownRect;
setup(function() {
var parent = fixture('OffsetDropdownTopLeft');
dropdown = parent.querySelector('iron-dropdown');
});
test('can be offset towards the bottom right', function(done) {
runAfterOpen(dropdown, function() {
dropdownRect = dropdown.getBoundingClientRect();
dropdown.verticalOffset = 10;
dropdown.horizontalOffset = 10;
// Force refit instead of waiting for requestAnimationFrame.
dropdown.refit();
offsetDropdownRect = dropdown.getBoundingClientRect();
// verticalAlign is top, so a positive offset moves down.
assert.equal(dropdownRect.top + 10, offsetDropdownRect.top, 'top ok');
// horizontalAlign is left, so a positive offset moves to the right.
assert.equal(dropdownRect.left + 10, offsetDropdownRect.left, 'left ok');
done();
});
});
test('can be offset towards the top left', function(done) {
runAfterOpen(dropdown, function() {
dropdownRect = dropdown.getBoundingClientRect();
dropdown.verticalOffset = -10;
dropdown.horizontalOffset = -10;
// Force refit instead of waiting for requestAnimationFrame.
dropdown.refit();
offsetDropdownRect = dropdown.getBoundingClientRect();
// verticalAlign is top, so a negative offset moves up.
assert.equal(dropdownRect.top - 10, offsetDropdownRect.top, 'top ok');
// horizontalAlign is left, so a negative offset moves to the left.
assert.equal(dropdownRect.left - 10, offsetDropdownRect.left, 'left ok');
done();
});
});
});
suite('when align is right/bottom, with an offset', function() {
var dropdownRect;
var offsetDropdownRect;
setup(function() {
var parent = fixture('OffsetDropdownBottomRight');
dropdown = parent.querySelector('iron-dropdown');
});
test('can be offset towards the top left', function(done) {
runAfterOpen(dropdown, function() {
dropdownRect = dropdown.getBoundingClientRect();
dropdown.verticalOffset = 10;
dropdown.horizontalOffset = 10;
// Force refit instead of waiting for requestAnimationFrame.
dropdown.refit();
offsetDropdownRect = dropdown.getBoundingClientRect();
// verticalAlign is bottom, so a positive offset moves up.
assert.equal(dropdownRect.bottom - 10, offsetDropdownRect.bottom, 'bottom ok');
// horizontalAlign is right, so a positive offset moves to the left.
assert.equal(dropdownRect.right - 10, offsetDropdownRect.right, 'right ok');
done();
});
});
test('can be offset towards the bottom right', function(done) {
runAfterOpen(dropdown, function() {
dropdownRect = dropdown.getBoundingClientRect();
dropdown.verticalOffset = -10;
dropdown.horizontalOffset = -10;
// Force refit instead of waiting for requestAnimationFrame.
dropdown.refit();
offsetDropdownRect = dropdown.getBoundingClientRect();
// verticalAlign is bottom, so a negative offset moves down.
assert.equal(dropdownRect.bottom + 10, offsetDropdownRect.bottom, 'bottom ok');
// horizontalAlign is right, so a positive offset moves to the right.
assert.equal(dropdownRect.right + 10, offsetDropdownRect.right, 'right ok');
done();
});
});
});
suite('RTL', function() {
var dropdownRect;
test('with horizontalAlign=left', function(done) {
var parent = fixture('RTLDropdownLeft');
dropdown = parent.querySelector('iron-dropdown');
runAfterOpen(dropdown, function() {
// In RTL, if `horizontalAlign` is "left", that's the same as
// being right-aligned in LTR. So the dropdown should be in the top
// right corner.
dropdownRect = dropdown.getBoundingClientRect();
expect(dropdownRect.top).to.be.equal(0);
expect(dropdownRect.right).to.be.equal(100);
done();
});
});
test('with horizontalAlign=right', function(done) {
var parent = fixture('RTLDropdownRight');
dropdown = parent.querySelector('iron-dropdown');
runAfterOpen(dropdown, function() {
// In RTL, if `horizontalAlign` is "right", that's the same as
// being left-aligned in LTR. So the dropdown should be in the top
// left corner.
dropdownRect = dropdown.getBoundingClientRect();
expect(dropdownRect.top).to.be.equal(0);
expect(dropdownRect.left).to.be.equal(0);
done();
});
});
});
suite('sizing target', function() {
setup(function() {
dropdown = fixture('sizingTarget');
content = Polymer.dom(dropdown).querySelector('.dropdown-content');
});
test('sizingTarget is the content element by default', function(done) {
runAfterOpen(dropdown, function() {
expect(dropdown.sizingTarget).to.be.equal(content);
expect(content.style.maxHeight).to.be.not.empty;
expect(content.style.maxWidth).to.be.not.empty;
done();
});
});
test('sizingTarget can be set to a child element', function(done) {
var subcontent = Polymer.dom(dropdown).querySelector('.subcontent');
dropdown.sizingTarget = subcontent;
runAfterOpen(dropdown, function() {
expect(dropdown.sizingTarget).to.be.equal(subcontent);
expect(subcontent.style.maxHeight).to.be.not.empty;
expect(subcontent.style.maxWidth).to.be.not.empty;
done();
});
});
});
});
</script>
</body>
</html>