2015-09-27 15:38:11 +02:00
// Time scale tests
describe ( 'Time scale tests' , function ( ) {
2017-04-02 14:49:00 +02:00
function createScale ( data , options ) {
var scaleID = 'myScale' ;
var mockContext = window . createMockContext ( ) ;
var Constructor = Chart . scaleService . getScaleConstructor ( 'time' ) ;
var scale = new Constructor ( {
ctx : mockContext ,
options : options ,
chart : {
data : data
} ,
id : scaleID
} ) ;
scale . update ( 400 , 50 ) ;
return scale ;
}
2017-06-15 13:20:16 +02:00
function getTicksValues ( ticks ) {
return ticks . map ( function ( tick ) {
return tick . value ;
} ) ;
}
2016-03-06 05:16:25 +01:00
beforeEach ( function ( ) {
2016-04-30 02:03:15 +02:00
// Need a time matcher for getValueFromPixel
2016-03-06 05:16:25 +01:00
jasmine . addMatchers ( {
2016-04-23 19:27:10 +02:00
toBeCloseToTime : function ( ) {
return {
compare : function ( actual , expected ) {
var result = false ;
var diff = actual . diff ( expected . value , expected . unit , true ) ;
2017-04-02 14:49:00 +02:00
result = Math . abs ( diff ) < ( expected . threshold !== undefined ? expected . threshold : 0.01 ) ;
2016-04-23 19:27:10 +02:00
return {
pass : result
} ;
}
2016-10-16 23:34:59 +02:00
} ;
2016-03-06 05:16:25 +01:00
}
} ) ;
2016-04-28 03:50:31 +02:00
} ) ;
2015-10-17 05:14:07 +02:00
it ( 'Should load moment.js as a dependency' , function ( ) {
expect ( window . moment ) . not . toBe ( undefined ) ;
} ) ;
2015-09-27 15:38:11 +02:00
it ( 'Should register the constructor with the scale service' , function ( ) {
var Constructor = Chart . scaleService . getScaleConstructor ( 'time' ) ;
expect ( Constructor ) . not . toBe ( undefined ) ;
expect ( typeof Constructor ) . toBe ( 'function' ) ;
} ) ;
it ( 'Should have the correct default config' , function ( ) {
var defaultConfig = Chart . scaleService . getScaleDefaults ( 'time' ) ;
expect ( defaultConfig ) . toEqual ( {
display : true ,
gridLines : {
2016-10-16 23:34:59 +02:00
color : 'rgba(0, 0, 0, 0.1)' ,
2016-05-17 21:11:29 +02:00
drawBorder : true ,
2015-09-27 15:38:11 +02:00
drawOnChartArea : true ,
drawTicks : true ,
2016-04-17 03:49:08 +02:00
tickMarkLength : 10 ,
2015-09-27 15:38:11 +02:00
lineWidth : 1 ,
offsetGridLines : false ,
2015-11-25 01:18:15 +01:00
display : true ,
2016-10-16 23:34:59 +02:00
zeroLineColor : 'rgba(0,0,0,0.25)' ,
2016-08-12 18:31:54 +02:00
zeroLineWidth : 1 ,
2017-03-21 11:38:09 +01:00
zeroLineBorderDash : [ ] ,
zeroLineBorderDashOffset : 0.0 ,
2016-08-12 18:31:54 +02:00
borderDash : [ ] ,
borderDashOffset : 0.0
2015-09-27 15:38:11 +02:00
} ,
2016-10-16 23:34:59 +02:00
position : 'bottom' ,
2015-09-27 15:38:11 +02:00
scaleLabel : {
labelString : '' ,
2016-04-17 00:38:03 +02:00
display : false
2015-09-27 15:38:11 +02:00
} ,
ticks : {
beginAtZero : false ,
2016-05-10 13:10:01 +02:00
minRotation : 0 ,
2016-04-17 00:38:03 +02:00
maxRotation : 50 ,
2015-09-27 15:38:11 +02:00
mirror : false ,
2016-11-05 01:41:54 +01:00
padding : 0 ,
2015-09-27 15:38:11 +02:00
reverse : false ,
2015-11-25 01:18:15 +01:00
display : true ,
2015-12-21 08:43:48 +01:00
callback : defaultConfig . ticks . callback , // make this nicer, then check explicitly below,
2016-02-15 15:41:35 +01:00
autoSkip : false ,
2016-05-11 11:43:22 +02:00
autoSkipPadding : 0 ,
2017-06-15 13:20:16 +02:00
labelOffset : 0 ,
minor : { } ,
major : { } ,
2015-09-27 15:38:11 +02:00
} ,
time : {
2016-03-02 16:40:58 +01:00
parser : false ,
2015-09-27 15:38:11 +02:00
format : false ,
unit : false ,
round : false ,
2016-05-11 10:34:22 +02:00
isoWeekday : false ,
2015-09-27 15:38:11 +02:00
displayFormat : false ,
Suport minUnit for time scale
When dealing with time-delineated datasets, often we have data for known
intervals of time. For example, we may have a dataset which represents number
of purchases per day:
```json
{
labels: ['2016-01-01', '2016-01-02', '2016-01-03']
datasets: [
{
data: [12, 87, 42]
}
],
'...': '...'
}
```
In this case, Chart.js will attempt to figure out the best interval to display
the data, and could pick `hours` as the unit. However, in this case, we would
prefer to just use the `days` interval since our data's granularity can not be
represented well with `hours`.
To remedy this, this commit adds the `minUnit` option which allows
users to (optionally) specify what the minimum unit they would like
to use.
2016-09-02 22:39:25 +02:00
minUnit : 'millisecond' ,
2015-12-01 02:42:48 +01:00
displayFormats : {
2016-10-16 23:34:59 +02:00
millisecond : 'h:mm:ss.SSS a' , // 11:20:01.123 AM
second : 'h:mm:ss a' , // 11:20:01 AM
2017-06-15 13:20:16 +02:00
minute : 'h:mm a' , // 11:20 AM
hour : 'hA' , // 5PM
day : 'MMM D' , // Sep 4
2016-10-16 23:34:59 +02:00
week : 'll' , // Week 46, or maybe "[W]WW - YYYY" ?
month : 'MMM YYYY' , // Sept 2015
quarter : '[Q]Q - YYYY' , // Q3
year : 'YYYY' // 2015
2017-06-15 13:20:16 +02:00
} ,
2015-09-27 15:38:11 +02:00
}
} ) ;
2015-10-19 01:48:57 +02:00
// Is this actually a function
expect ( defaultConfig . ticks . callback ) . toEqual ( jasmine . any ( Function ) ) ;
2015-09-27 15:38:11 +02:00
} ) ;
2017-04-02 14:49:00 +02:00
describe ( 'when given inputs of different types' , function ( ) {
2015-12-05 22:45:31 +01:00
// Helper to build date objects
function newDateFromRef ( days ) {
return moment ( '01/01/2015 12:00' , 'DD/MM/YYYY HH:mm' ) . add ( days , 'd' ) . toDate ( ) ;
}
2017-04-02 14:49:00 +02:00
it ( 'should accept labels as strings' , function ( ) {
var mockData = {
labels : [ '2015-01-01T12:00:00' , '2015-01-02T21:00:00' , '2015-01-03T22:00:00' , '2015-01-05T23:00:00' , '2015-01-07T03:00' , '2015-01-08T10:00' , '2015-01-10T12:00' ] , // days
} ;
2015-12-05 22:45:31 +01:00
2017-05-30 00:40:10 +02:00
var scaleOptions = Chart . scaleService . getScaleDefaults ( 'time' ) ;
var scale = createScale ( mockData , scaleOptions ) ;
2017-04-02 14:49:00 +02:00
scale . update ( 1000 , 200 ) ;
2017-06-15 13:20:16 +02:00
var ticks = getTicksValues ( scale . ticks ) ;
expect ( ticks ) . toEqual ( [ 'Jan 2015' , 'Jan 2' , 'Jan 3' , 'Jan 4' , 'Jan 5' , 'Jan 6' , 'Jan 7' , 'Jan 8' , 'Jan 9' , 'Jan 10' , 'Jan 11' ] ) ;
2015-12-05 22:45:31 +01:00
} ) ;
2017-04-02 14:49:00 +02:00
it ( 'should accept labels as date objects' , function ( ) {
var mockData = {
labels : [ newDateFromRef ( 0 ) , newDateFromRef ( 1 ) , newDateFromRef ( 2 ) , newDateFromRef ( 4 ) , newDateFromRef ( 6 ) , newDateFromRef ( 7 ) , newDateFromRef ( 9 ) ] , // days
} ;
var scale = createScale ( mockData , Chart . scaleService . getScaleDefaults ( 'time' ) ) ;
scale . update ( 1000 , 200 ) ;
2017-06-15 13:20:16 +02:00
var ticks = getTicksValues ( scale . ticks ) ;
expect ( ticks ) . toEqual ( [ 'Jan 2015' , 'Jan 2' , 'Jan 3' , 'Jan 4' , 'Jan 5' , 'Jan 6' , 'Jan 7' , 'Jan 8' , 'Jan 9' , 'Jan 10' , 'Jan 11' ] ) ;
2017-04-02 14:49:00 +02:00
} ) ;
2016-01-23 18:44:55 +01:00
2017-04-02 14:49:00 +02:00
it ( 'should accept data as xy points' , function ( ) {
var chart = window . acquireChart ( {
type : 'line' ,
data : {
datasets : [ {
xAxisID : 'xScale0' ,
data : [ {
x : newDateFromRef ( 0 ) ,
y : 1
} , {
x : newDateFromRef ( 1 ) ,
y : 10
} , {
x : newDateFromRef ( 2 ) ,
y : 0
} , {
x : newDateFromRef ( 4 ) ,
y : 5
} , {
x : newDateFromRef ( 6 ) ,
y : 77
} , {
x : newDateFromRef ( 7 ) ,
y : 9
} , {
x : newDateFromRef ( 9 ) ,
y : 5
} ]
2016-04-28 03:50:31 +02:00
} ] ,
2017-04-02 14:49:00 +02:00
} ,
options : {
scales : {
xAxes : [ {
id : 'xScale0' ,
type : 'time' ,
position : 'bottom'
} ] ,
}
2016-04-28 03:50:31 +02:00
}
2017-04-02 14:49:00 +02:00
} ) ;
2016-01-23 18:44:55 +01:00
2017-04-02 14:49:00 +02:00
var xScale = chart . scales . xScale0 ;
xScale . update ( 800 , 200 ) ;
2017-06-15 13:20:16 +02:00
var ticks = getTicksValues ( xScale . ticks ) ;
expect ( ticks ) . toEqual ( [ 'Jan 2015' , 'Jan 2' , 'Jan 3' , 'Jan 4' , 'Jan 5' , 'Jan 6' , 'Jan 7' , 'Jan 8' , 'Jan 9' , 'Jan 10' , 'Jan 11' ] ) ;
2017-04-02 14:49:00 +02:00
} ) ;
2016-01-23 18:44:55 +01:00
} ) ;
2016-03-02 16:40:58 +01:00
it ( 'should allow custom time parsers' , function ( ) {
2016-09-06 11:10:44 +02:00
var chart = window . acquireChart ( {
2016-04-28 03:50:31 +02:00
type : 'line' ,
data : {
datasets : [ {
xAxisID : 'xScale0' ,
data : [ {
x : 375068900 ,
y : 1
} ]
} ] ,
2016-03-02 16:40:58 +01:00
} ,
2016-04-28 03:50:31 +02:00
options : {
scales : {
xAxes : [ {
id : 'xScale0' ,
type : 'time' ,
position : 'bottom' ,
time : {
unit : 'day' ,
round : true ,
2016-10-16 23:34:59 +02:00
parser : function ( label ) {
2016-04-28 03:50:31 +02:00
return moment . unix ( label ) ;
}
}
} ] ,
}
}
2016-03-02 16:40:58 +01:00
} ) ;
// Counts down because the lines are drawn top to bottom
2016-09-06 11:10:44 +02:00
var xScale = chart . scales . xScale0 ;
2016-04-28 03:50:31 +02:00
// Counts down because the lines are drawn top to bottom
2017-06-15 13:20:16 +02:00
expect ( xScale . ticks [ 0 ] . value ) . toEqualOneOf ( [ 'Nov 19' , 'Nov 20' , 'Nov 21' ] ) ; // handle time zone changes
expect ( xScale . ticks [ 1 ] . value ) . toEqualOneOf ( [ 'Nov 19' , 'Nov 20' , 'Nov 21' ] ) ; // handle time zone changes
2016-03-02 16:40:58 +01:00
} ) ;
2015-10-17 05:14:07 +02:00
it ( 'should build ticks using the config unit' , function ( ) {
2015-09-27 15:38:11 +02:00
var mockData = {
2016-10-16 23:34:59 +02:00
labels : [ '2015-01-01T20:00:00' , '2015-01-02T21:00:00' ] , // days
2015-09-27 15:38:11 +02:00
} ;
2016-01-23 18:44:55 +01:00
var config = Chart . helpers . clone ( Chart . scaleService . getScaleDefaults ( 'time' ) ) ;
2015-09-27 15:38:11 +02:00
config . time . unit = 'hour' ;
2017-04-02 14:49:00 +02:00
var scale = createScale ( mockData , config ) ;
scale . update ( 2500 , 200 ) ;
2017-06-15 13:20:16 +02:00
var ticks = getTicksValues ( scale . ticks ) ;
2017-05-30 00:40:10 +02:00
2017-06-15 13:20:16 +02:00
expect ( ticks ) . toEqual ( [ '8PM' , '9PM' , '10PM' , '11PM' , 'Jan 2' , '1AM' , '2AM' , '3AM' , '4AM' , '5AM' , '6AM' , '7AM' , '8AM' , '9AM' , '10AM' , '11AM' , '12PM' , '1PM' , '2PM' , '3PM' , '4PM' , '5PM' , '6PM' , '7PM' , '8PM' , '9PM' ] ) ;
2015-09-27 15:38:11 +02:00
} ) ;
Suport minUnit for time scale
When dealing with time-delineated datasets, often we have data for known
intervals of time. For example, we may have a dataset which represents number
of purchases per day:
```json
{
labels: ['2016-01-01', '2016-01-02', '2016-01-03']
datasets: [
{
data: [12, 87, 42]
}
],
'...': '...'
}
```
In this case, Chart.js will attempt to figure out the best interval to display
the data, and could pick `hours` as the unit. However, in this case, we would
prefer to just use the `days` interval since our data's granularity can not be
represented well with `hours`.
To remedy this, this commit adds the `minUnit` option which allows
users to (optionally) specify what the minimum unit they would like
to use.
2016-09-02 22:39:25 +02:00
it ( 'build ticks honoring the minUnit' , function ( ) {
var mockData = {
2016-10-16 23:34:59 +02:00
labels : [ '2015-01-01T20:00:00' , '2015-01-02T21:00:00' ] , // days
Suport minUnit for time scale
When dealing with time-delineated datasets, often we have data for known
intervals of time. For example, we may have a dataset which represents number
of purchases per day:
```json
{
labels: ['2016-01-01', '2016-01-02', '2016-01-03']
datasets: [
{
data: [12, 87, 42]
}
],
'...': '...'
}
```
In this case, Chart.js will attempt to figure out the best interval to display
the data, and could pick `hours` as the unit. However, in this case, we would
prefer to just use the `days` interval since our data's granularity can not be
represented well with `hours`.
To remedy this, this commit adds the `minUnit` option which allows
users to (optionally) specify what the minimum unit they would like
to use.
2016-09-02 22:39:25 +02:00
} ;
var config = Chart . helpers . clone ( Chart . scaleService . getScaleDefaults ( 'time' ) ) ;
config . time . minUnit = 'day' ;
2017-04-02 14:49:00 +02:00
var scale = createScale ( mockData , config ) ;
2017-06-15 13:20:16 +02:00
var ticks = getTicksValues ( scale . ticks ) ;
expect ( ticks ) . toEqual ( [ 'Jan 2015' , 'Jan 2' , 'Jan 3' ] ) ;
Suport minUnit for time scale
When dealing with time-delineated datasets, often we have data for known
intervals of time. For example, we may have a dataset which represents number
of purchases per day:
```json
{
labels: ['2016-01-01', '2016-01-02', '2016-01-03']
datasets: [
{
data: [12, 87, 42]
}
],
'...': '...'
}
```
In this case, Chart.js will attempt to figure out the best interval to display
the data, and could pick `hours` as the unit. However, in this case, we would
prefer to just use the `days` interval since our data's granularity can not be
represented well with `hours`.
To remedy this, this commit adds the `minUnit` option which allows
users to (optionally) specify what the minimum unit they would like
to use.
2016-09-02 22:39:25 +02:00
} ) ;
2015-10-17 05:14:07 +02:00
it ( 'should build ticks using the config diff' , function ( ) {
2015-09-27 15:38:11 +02:00
var mockData = {
2016-10-16 23:34:59 +02:00
labels : [ '2015-01-01T20:00:00' , '2015-02-02T21:00:00' , '2015-02-21T01:00:00' ] , // days
2015-09-27 15:38:11 +02:00
} ;
2016-01-23 18:44:55 +01:00
var config = Chart . helpers . clone ( Chart . scaleService . getScaleDefaults ( 'time' ) ) ;
2015-09-27 15:38:11 +02:00
config . time . unit = 'week' ;
config . time . round = 'week' ;
2017-04-02 14:49:00 +02:00
var scale = createScale ( mockData , config ) ;
scale . update ( 800 , 200 ) ;
2017-06-15 13:20:16 +02:00
var ticks = getTicksValues ( scale . ticks ) ;
2016-01-30 22:35:10 +01:00
// last date is feb 15 because we round to start of week
2017-06-15 13:20:16 +02:00
expect ( ticks ) . toEqual ( [ 'Dec 28, 2014' , 'Jan 4, 2015' , 'Jan 11, 2015' , 'Jan 18, 2015' , 'Jan 25, 2015' , 'Feb 2015' , 'Feb 8, 2015' , 'Feb 15, 2015' ] ) ;
2015-09-27 15:38:11 +02:00
} ) ;
2017-04-02 14:49:00 +02:00
describe ( 'when specifying limits' , function ( ) {
2016-01-23 18:44:55 +01:00
var mockData = {
2017-04-02 14:49:00 +02:00
labels : [ '2015-01-01T20:00:00' , '2015-01-02T20:00:00' , '2015-01-03T20:00:00' ] ,
2016-01-23 18:44:55 +01:00
} ;
2017-04-02 14:49:00 +02:00
var config ;
beforeEach ( function ( ) {
config = Chart . helpers . clone ( Chart . scaleService . getScaleDefaults ( 'time' ) ) ;
2016-01-23 18:44:55 +01:00
} ) ;
2017-04-02 14:49:00 +02:00
it ( 'should use the min option' , function ( ) {
config . time . unit = 'day' ;
config . time . min = '2014-12-29T04:00:00' ;
var scale = createScale ( mockData , config ) ;
2017-06-15 13:20:16 +02:00
expect ( scale . ticks [ 0 ] . value ) . toEqual ( 'Dec 28' ) ;
2017-04-02 14:49:00 +02:00
} ) ;
it ( 'should use the max option' , function ( ) {
config . time . unit = 'day' ;
config . time . max = '2015-01-05T06:00:00' ;
var scale = createScale ( mockData , config ) ;
2017-06-15 13:20:16 +02:00
expect ( scale . ticks [ scale . ticks . length - 1 ] . value ) . toEqual ( 'Jan 6' ) ;
2017-04-02 14:49:00 +02:00
} ) ;
2016-01-23 18:44:55 +01:00
} ) ;
2016-05-11 10:34:22 +02:00
it ( 'Should use the isoWeekday option' , function ( ) {
var mockData = {
labels : [
2016-10-16 23:34:59 +02:00
'2015-01-01T20:00:00' , // Thursday
'2015-01-02T20:00:00' , // Friday
'2015-01-03T20:00:00' // Saturday
2016-05-11 10:34:22 +02:00
]
} ;
var config = Chart . helpers . clone ( Chart . scaleService . getScaleDefaults ( 'time' ) ) ;
config . time . unit = 'week' ;
// Wednesday
config . time . isoWeekday = 3 ;
2017-04-02 14:49:00 +02:00
var scale = createScale ( mockData , config ) ;
2017-06-15 13:20:16 +02:00
var ticks = getTicksValues ( scale . ticks ) ;
expect ( ticks ) . toEqual ( [ 'Dec 31, 2014' , 'Jan 7, 2015' ] ) ;
2016-05-11 10:34:22 +02:00
} ) ;
2017-04-02 14:49:00 +02:00
describe ( 'when rendering several days' , function ( ) {
2016-09-06 11:10:44 +02:00
var chart = window . acquireChart ( {
2016-04-28 03:50:31 +02:00
type : 'line' ,
data : {
datasets : [ {
xAxisID : 'xScale0' ,
data : [ ]
} ] ,
2016-10-16 23:34:59 +02:00
labels : [ '2015-01-01T20:00:00' , '2015-01-02T21:00:00' , '2015-01-03T22:00:00' , '2015-01-05T23:00:00' , '2015-01-07T03:00' , '2015-01-08T10:00' , '2015-01-10T12:00' ] , // days
2015-11-13 15:38:35 +01:00
} ,
2016-04-28 03:50:31 +02:00
options : {
scales : {
xAxes : [ {
id : 'xScale0' ,
type : 'time' ,
position : 'bottom'
} ] ,
}
}
2015-09-27 15:38:11 +02:00
} ) ;
2016-09-06 11:10:44 +02:00
var xScale = chart . scales . xScale0 ;
2015-09-27 15:38:11 +02:00
2017-05-30 00:40:10 +02:00
it ( 'should be bounded by the nearest week beginnings' , function ( ) {
expect ( xScale . getValueForPixel ( xScale . left ) ) . toBeGreaterThan ( moment ( chart . data . labels [ 0 ] ) . startOf ( 'week' ) ) ;
expect ( xScale . getValueForPixel ( xScale . right ) ) . toBeLessThan ( moment ( chart . data . labels [ chart . data . labels . length - 1 ] ) . add ( 1 , 'week' ) . endOf ( 'week' ) ) ;
2017-04-02 14:49:00 +02:00
} ) ;
it ( 'should convert between screen coordinates and times' , function ( ) {
2017-05-30 00:40:10 +02:00
var timeRange = moment ( xScale . max ) . valueOf ( ) - moment ( xScale . min ) . valueOf ( ) ;
var msPerPix = timeRange / xScale . width ;
var firstPointOffsetMs = moment ( chart . config . data . labels [ 0 ] ) . valueOf ( ) - xScale . min ;
var firstPointPixel = xScale . left + firstPointOffsetMs / msPerPix ;
var lastPointOffsetMs = moment ( chart . config . data . labels [ chart . config . data . labels . length - 1 ] ) . valueOf ( ) - xScale . min ;
var lastPointPixel = xScale . left + lastPointOffsetMs / msPerPix ;
expect ( xScale . getPixelForValue ( '' , 0 , 0 ) ) . toBeCloseToPixel ( firstPointPixel ) ;
expect ( xScale . getPixelForValue ( chart . data . labels [ 0 ] ) ) . toBeCloseToPixel ( firstPointPixel ) ;
expect ( xScale . getValueForPixel ( firstPointPixel ) ) . toBeCloseToTime ( {
2017-04-02 14:49:00 +02:00
value : moment ( chart . data . labels [ 0 ] ) ,
unit : 'hour' ,
} ) ;
2017-05-30 00:40:10 +02:00
expect ( xScale . getPixelForValue ( '' , 6 , 0 ) ) . toBeCloseToPixel ( lastPointPixel ) ;
expect ( xScale . getValueForPixel ( lastPointPixel ) ) . toBeCloseToTime ( {
2017-04-02 14:49:00 +02:00
value : moment ( chart . data . labels [ 6 ] ) ,
unit : 'hour'
} ) ;
} ) ;
} ) ;
2016-04-24 02:08:00 +02:00
2017-04-02 14:49:00 +02:00
describe ( 'when rendering several years' , function ( ) {
var chart = window . acquireChart ( {
type : 'line' ,
data : {
labels : [ '2005-07-04' , '2017-01-20' ] ,
} ,
options : {
scales : {
xAxes : [ {
id : 'xScale0' ,
type : 'time' ,
position : 'bottom'
} ] ,
}
}
} ) ;
var xScale = chart . scales . xScale0 ;
xScale . update ( 800 , 200 ) ;
2017-05-30 00:40:10 +02:00
var step = xScale . ticksAsTimestamps [ 1 ] - xScale . ticksAsTimestamps [ 0 ] ;
var stepsAmount = Math . floor ( ( xScale . max - xScale . min ) / step ) ;
2017-04-02 14:49:00 +02:00
2017-05-30 00:40:10 +02:00
it ( 'should be bounded by nearest step year starts' , function ( ) {
2017-04-02 14:49:00 +02:00
expect ( xScale . getValueForPixel ( xScale . left ) ) . toBeCloseToTime ( {
2017-05-30 00:40:10 +02:00
value : moment ( xScale . min ) . startOf ( 'year' ) ,
2017-04-02 14:49:00 +02:00
unit : 'hour' ,
} ) ;
expect ( xScale . getValueForPixel ( xScale . right ) ) . toBeCloseToTime ( {
2017-05-30 00:40:10 +02:00
value : moment ( xScale . min + step * stepsAmount ) . endOf ( 'year' ) ,
2017-04-02 14:49:00 +02:00
unit : 'hour' ,
} ) ;
2015-09-27 15:38:11 +02:00
} ) ;
2017-04-02 14:49:00 +02:00
it ( 'should build the correct ticks' , function ( ) {
2017-05-30 00:40:10 +02:00
// Where 'correct' is a two year spacing.
2017-06-15 13:20:16 +02:00
expect ( getTicksValues ( xScale . ticks ) ) . toEqual ( [ '2005' , '2007' , '2009' , '2011' , '2013' , '2015' , '2017' , '2019' ] ) ;
2017-04-02 14:49:00 +02:00
} ) ;
it ( 'should have ticks with accurate labels' , function ( ) {
var ticks = xScale . ticks ;
2017-05-30 00:40:10 +02:00
var pixelsPerYear = xScale . width / 14 ;
2017-04-02 14:49:00 +02:00
for ( var i = 0 ; i < ticks . length - 1 ; i ++ ) {
var offset = 2 * pixelsPerYear * i ;
expect ( xScale . getValueForPixel ( xScale . left + offset ) ) . toBeCloseToTime ( {
2017-06-15 13:20:16 +02:00
value : moment ( ticks [ i ] . value + '-01-01' ) ,
2017-04-02 14:49:00 +02:00
unit : 'day' ,
threshold : 0.5 ,
} ) ;
}
2016-04-30 02:03:15 +02:00
} ) ;
2016-01-23 18:44:55 +01:00
} ) ;
it ( 'should get the correct label for a data value' , function ( ) {
2016-09-06 11:10:44 +02:00
var chart = window . acquireChart ( {
2016-04-28 03:50:31 +02:00
type : 'line' ,
data : {
datasets : [ {
xAxisID : 'xScale0' ,
2016-10-31 01:34:06 +01:00
data : [ null , 10 , 3 ]
2016-04-28 03:50:31 +02:00
} ] ,
2016-10-16 23:34:59 +02:00
labels : [ '2015-01-01T20:00:00' , '2015-01-02T21:00:00' , '2015-01-03T22:00:00' , '2015-01-05T23:00:00' , '2015-01-07T03:00' , '2015-01-08T10:00' , '2015-01-10T12:00' ] , // days
2016-01-23 18:44:55 +01:00
} ,
2016-04-28 03:50:31 +02:00
options : {
scales : {
xAxes : [ {
id : 'xScale0' ,
type : 'time' ,
position : 'bottom'
} ] ,
}
}
2016-01-23 18:44:55 +01:00
} ) ;
2016-09-06 11:10:44 +02:00
var xScale = chart . scales . xScale0 ;
2016-10-31 01:34:06 +01:00
expect ( xScale . getLabelForIndex ( 0 , 0 ) ) . toBeTruthy ( ) ;
2016-04-28 03:50:31 +02:00
expect ( xScale . getLabelForIndex ( 0 , 0 ) ) . toBe ( '2015-01-01T20:00:00' ) ;
expect ( xScale . getLabelForIndex ( 6 , 0 ) ) . toBe ( '2015-01-10T12:00' ) ;
2015-09-27 15:38:11 +02:00
} ) ;
2016-09-06 11:34:33 +02:00
2016-06-09 06:34:15 +02:00
it ( 'should get the correct pixel for only one data in the dataset' , function ( ) {
var chart = window . acquireChart ( {
type : 'line' ,
data : {
2016-10-16 23:34:59 +02:00
labels : [ '2016-05-27' ] ,
2016-06-09 06:34:15 +02:00
datasets : [ {
2016-09-06 11:34:33 +02:00
xAxisID : 'xScale0' ,
2016-06-09 06:34:15 +02:00
data : [ 5 ]
} ]
} ,
options : {
scales : {
xAxes : [ {
2016-09-06 11:34:33 +02:00
id : 'xScale0' ,
2016-06-09 06:34:15 +02:00
display : true ,
2016-10-16 23:34:59 +02:00
type : 'time'
2016-06-09 06:34:15 +02:00
} ]
}
}
} ) ;
2016-09-06 11:10:44 +02:00
var xScale = chart . scales . xScale0 ;
2017-05-30 00:40:10 +02:00
var pixel = xScale . getPixelForValue ( '' , 0 , 0 ) ;
2016-06-09 06:34:15 +02:00
2017-05-30 00:40:10 +02:00
expect ( xScale . getValueForPixel ( pixel ) . valueOf ( ) ) . toEqual ( moment ( chart . data . labels [ 0 ] ) . valueOf ( ) ) ;
2016-06-09 06:34:15 +02:00
} ) ;
2017-04-04 02:48:55 +02:00
it ( 'does not create a negative width chart when hidden' , function ( ) {
var chart = window . acquireChart ( {
type : 'line' ,
data : {
datasets : [ {
data : [ ]
} ]
} ,
options : {
scales : {
xAxes : [ {
type : 'time' ,
time : {
min : moment ( ) . subtract ( 1 , 'months' ) ,
max : moment ( ) ,
}
} ] ,
} ,
responsive : true ,
} ,
} , {
wrapper : {
style : 'display: none' ,
} ,
} ) ;
expect ( chart . scales [ 'y-axis-0' ] . width ) . toEqual ( 0 ) ;
expect ( chart . scales [ 'y-axis-0' ] . maxWidth ) . toEqual ( 0 ) ;
expect ( chart . width ) . toEqual ( 0 ) ;
} ) ;
2015-10-17 05:14:07 +02:00
} ) ;