it('updates view elements', function () {
var calculator = testCalculator,
view;
view = InclinationView({
reading: Reading(),
observation: Observation(),
calculator: calculator
});
expect(view._inclinationAngle.innerHTML).to.equal(
Format.degreesAndDegreesMinutes(calculator.inclination()));
expect(view._horizontalComponent.textContent).to.equal(
Format.roundHalfToEven(
calculator.horizontalComponent(),3) + 'nT');
expect(view._verticalComponent.textContent).to.equal(
Format.roundHalfToEven(
calculator.verticalComponent(),3) + 'nT');
expect(view._southDownMinusNorthUp.textContent).to.equal(
Format.roundHalfToEven(
(calculator.southDownMinusNorthUp()*60),3) + '\'');
expect(view._northDownMinusSouthUp.textContent).to.equal(
Format.roundHalfToEven(
(calculator.northDownMinusSouthUp()*60),3) + '\'');
});
it('updates view elements', function () {
view = DeclinationView({
reading: Reading(),
observation: Observation(),
calculator: calculator
});
// These are equal, this is probably bs.
expect(view._magneticSouthMeridian.innerHTML).to.equal(
Format.degreesAndDegreesMinutes(
calculator.magneticSouthMeridian()));
expect(view._meanMark.textContent).to.equal(
Format.roundHalfToEven(calculator.meanMark(),3) + '°');
expect(view._magneticAzimuthOfMark.textContent).to.equal(
Format.roundHalfToEven(
calculator.magneticAzimuthMark(),3) + '°');
expect(view._trueAzimuthOfMark.textContent).to.equal('' +
calculator.trueAzimuthOfMark() + '°');
expect(view._magneticDeclination.innerHTML).to.equal(
Format.degreesAndDegreesMinutes(
calculator.magneticDeclination()));
expect(view._westUpMinusEastDown.textContent).to.equal(
Format.roundHalfToEven(
(calculator.westUpMinusEastDown()*60),3) + '\'');
expect(view._eastUpMinusWestDown.textContent).to.equal(
Format.roundHalfToEven(
(calculator.eastUpMinusWestDown()*60),3) + '\'');
});
describe('Initialize', function () {
var i = 0,
len = 0,
reading = Reading(),
measurements = reading.getMeasurements(),
observation = Observation(),
view;
view = InclinationView({
reading: reading,
observation: observation,
calculator: testCalculator
});
it('binds measurement change to render', function () {
var spy = sinon.spy(view, 'render');
var testmeasurements = [
measurements[Measurement.SOUTH_DOWN][0],
measurements[Measurement.NORTH_UP][0],
measurements[Measurement.SOUTH_UP][0],
measurements[Measurement.NORTH_DOWN][0]
];
for (i = 0, len = testmeasurements.length; i < len; i++){
testmeasurements[i].trigger('change');
expect(spy.callCount).to.equal(i+1);
}
});
});
it('add a mesurement to underlying measurements collection', function(){
var reading = Reading(TESTOBJECT);
var measurements = reading.get('measurements');
measurements.add(testmeasure);
measurements = reading.get('measurements');
var data = measurements.data();
expect(data[data.length-1]).to.deep.equal(testmeasure);
});
_initialize = function () {
if (_this.get('readings') === null) {
_this.set({
readings: Collection([
Reading({set_number: 1}),
Reading({set_number: 2}),
Reading({set_number: 3}),
Reading({set_number: 4})
])
});
}
if (_this.get('begin') === null) {
_this.set({
begin: new Date().getTime()
});
}
_this.on('change:begin', _updateMeasurementTimes);
};
beforeEach(function () {
reading = Reading();
calculator = ObservationBaselineCalculator();
factory = ObservatoryFactory();
view = VerticalIntensitySummaryView({
el: document.createElement('tr'),
reading: reading,
calculator: calculator,
factory:factory
});
measurements = factory.getHorizontalIntensityMeasurements(reading);
renderSpy = sinon.spy(view, 'render');
});
beforeEach(function () {
reading = Reading();
calculator = Calculator();
factory = ObservatoryFactory();
view = DeclinationSummaryView({
el: document.createElement('tr'),
reading: reading,
calculator: calculator,
factory: factory
});
measurements = factory.getDeclinationMeasurements(reading);
renderSpy = sinon.spy(view, 'render');
});
it ('calls callback for each measurement', function () {
var callback = sinon.spy(),
reading = Reading(),
measurements = reading.get('measurements').data(),
m,
mlen;
reading.eachMeasurement(callback);
// called once for each measurement
expect(callback.callCount).to.equal(measurements.length);
// called in the correct order
for (m = 0, mlen = measurements.length; m < mlen; m++) {
expect(callback.getCall(m).args[0]).to.equal(measurements[m]);
}
});
describe('Initialize', function () {
var i = 0,
len = 0,
reading = Reading(),
measurements = reading.getMeasurements(),
observation = Observation(),
view;
view = DeclinationView({
reading: reading,
observation: observation,
calculator: testCalculator
});
it('binds measurement change to render', function () {
var spy = sinon.spy(view, 'render');
var testmeasurements = [
measurements[Measurement.FIRST_MARK_UP][0],
measurements[Measurement.FIRST_MARK_DOWN][0],
measurements[Measurement.WEST_DOWN][0],
measurements[Measurement.EAST_DOWN][0],
measurements[Measurement.WEST_UP][0],
measurements[Measurement.EAST_UP][0],
measurements[Measurement.SECOND_MARK_UP][0],
measurements[Measurement.SECOND_MARK_DOWN][0]
];
for (i = 0, len = testmeasurements.length; i < len; i++){
testmeasurements[i].trigger('change');
expect(spy.callCount).to.equal(i+1);
}
});
// it('binds calculator change to render', function () {
// view.called = false;
// testCalculator.trigger('change');
// expect(view.called).to.equal(true);
// });
});
it('Should set shift +/- 180', function () {
var calculator = Calculator(),
dropDown,
el = document.createElement('tr'),
view,
reading = Reading();
view = DeclinationSummaryView({
el: el,
reading: reading,
calculator: calculator
});
dropDown = view.el.querySelector('.shift > select');
expect(reading.get('declination_shift')).to.equal(0);
changeSelectValue(dropDown, '-180');
expect(reading.get('declination_shift')).to.equal(-180);
changeSelectValue(dropDown, '180');
expect(reading.get('declination_shift')).to.equal(180);
});
it('Should toggle valid state', function () {
var view,
checkBox,
checkBoxBefore,
checkBoxAfter,
reading = Reading(),
calculator = ObservationBaselineCalculator();
view = VerticalIntensitySummaryView({
el: document.createElement('tr'),
reading: reading,
calculator: calculator
});
checkBox = view.el.querySelector('.valid > input');
checkBoxBefore = checkBox.checked;
checkBoxAfter = checkBoxBefore;
checkBox.dispatchEvent(getClickEvent());
checkBoxAfter = checkBox.checked;
expect(checkBoxBefore).to.not.equal(checkBoxAfter);
expect(checkBoxAfter).to.be.equal(false);
});
'e': -300.1,
'z': 47754.02,
'f': 52629.28
});
// data from BOU20132861836.bns
var READING = Reading({
'id': 1,
'set_number': 1,
'declination_valid': true,
'horizontal_intensity_valid': true,
'vertical_intensity_valid': true,
'observer': 'Eddie',
'annotation': 'This is a test',
'measurements': Collection([
meas1, meas2, meas3, meas4, meas5, meas6,
meas7, meas8, meas9, measA, measB, measC
]),
startH: 1388772631000, endH: 1388772631000,
absH: 18664.830905707, baseH: -2178.7015942929,
startZ: 1388772631000, endZ: 1388772631000,
absZ: 49034.335971417, baseZ: 1470.1409714166,
startD: 1388772260000, endD: 1388772260000,
absD: 169.78791666667, baseD: 169.82565118348
});
describe('Unit tests for ObservationBaselineCalculator', function () {
// --------------------------------------------------------------