<!DOCTYPE html>
<!--
Copyright (c) 2013 The Chromium Authors. All rights reserved.
Use of this source code is governed by a BSD-style license that can be
found in the LICENSE file.
-->

<link rel="import" href="/extras/about_tracing/mock_tracing_controller_client.html">
<link rel="import" href="/extras/about_tracing/record_and_capture_controller.html">

<script>
'use strict';

tv.b.unittest.testSuite(function() { // @suppress longLineCheck
  var testData = [
    {name: 'a', args: {}, pid: 52, ts: 15000, cat: 'foo', tid: 53, ph: 'B'},
    {name: 'a', args: {}, pid: 52, ts: 19000, cat: 'foo', tid: 53, ph: 'E'},
    {name: 'b', args: {}, pid: 52, ts: 32000, cat: 'foo', tid: 53, ph: 'B'},
    {name: 'b', args: {}, pid: 52, ts: 54000, cat: 'foo', tid: 53, ph: 'E'}
  ];

  test('fullRecording', function() {
    return new Promise(function(resolve, reject) {
      var mock = new tv.e.about_tracing.MockTracingControllerClient();
      mock.expectRequest('endRecording', function() {
        return '';
      });
      mock.expectRequest('getCategories', function() {
        setTimeout(function() {
          recordingPromise.selectionDlg.clickRecordButton();
        }, 20);
        return JSON.stringify(['a', 'b', 'c']);
      });
      mock.expectRequest('beginRecording', function(recordingOptions) {
        assertTrue(typeof recordingOptions.categoryFilter === 'string');
        assertTrue(typeof recordingOptions.useSystemTracing === 'boolean');
        assertTrue(typeof recordingOptions.useSampling === 'boolean');
        assertTrue(typeof recordingOptions.useContinuousTracing === 'boolean');
        setTimeout(function() {
          recordingPromise.progressDlg.clickStopButton();
        }, 10);
        return '';
      });
      mock.expectRequest('endRecording', function(data) {
        return JSON.stringify(testData);
      });

      var recordingPromise = tv.e.about_tracing.beginRecording(mock);

      return recordingPromise.then(
          function(data) {
            mock.assertAllRequestsHandled();
            var testDataString = JSON.stringify(testData);
            assertEquals(testDataString, data);
            resolve();
          },
          function(error) {
            reject('This should never be reached');
          });
    });
  });

  test('monitoring', function() {
    return new Promise(function(resolve, reject) {
      var mock = new tv.e.about_tracing.MockTracingControllerClient();

      mock.expectRequest('beginMonitoring', function(monitoringOptions) {
        assertTrue(typeof monitoringOptions.categoryFilter === 'string');
        assertTrue(typeof monitoringOptions.useSystemTracing === 'boolean');
        assertTrue(typeof monitoringOptions.useSampling === 'boolean');
        assertTrue(typeof monitoringOptions.useContinuousTracing === 'boolean');
        setTimeout(function() {
          var capturePromise = tv.e.about_tracing.captureMonitoring(mock);
          capturePromise.then(
              function(data) {
                var testDataString = JSON.stringify(testData);
                assertEquals(testDataString, data);
              },
              function(error) {
                reject();
              });
        }, 10);
        return '';
      });

      mock.expectRequest('captureMonitoring', function(data) {
        setTimeout(function() {
          var endPromise = tv.e.about_tracing.endMonitoring(mock);
          endPromise.then(
              function(data) {
                mock.assertAllRequestsHandled();
                resolve();
              },
              function(error) {
                reject();
              });
        }, 10);
        return JSON.stringify(testData);
      });

      mock.expectRequest('endMonitoring', function(data) {
      });

      tv.e.about_tracing.beginMonitoring(mock);
    });
  });
});
</script>