/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

var Ember = require('ember');
var App = require('app');
var modelSetup = require('test/init_model_test');

require('controllers/wizard/step4_controller');
describe('App.WizardStep4Controller', function () {

  var services = [
    'HDFS', 'GANGLIA', 'OOZIE', 'HIVE', 'HBASE', 'PIG', 'SCOOP', 'ZOOKEEPER', 'SMARTSENSE', 'LOGSEARCH',
    'YARN', 'MAPREDUCE2', 'FALCON', 'TEZ', 'STORM', 'AMBARI_METRICS', 'RANGER', 'SPARK', 'SLIDER', 'ATLAS', 'AMBARI_INFRA_SOLR'
  ];
  var controller;

  beforeEach(function() {
    controller = App.WizardStep4Controller.create();
    services.forEach(function(serviceName) {
      controller.pushObject(App.StackService.createRecord({
        'serviceName':serviceName, 'isSelected': true, 'isHiddenOnSelectServicePage': false, 'isInstalled': false, 'isDisabled': 'HDFS' === serviceName, isDFS: 'HDFS' === serviceName
      }));
    });
  });

  var generateSelectedServicesContent = function(selectedServiceNames) {
    var allServices = services.slice(0);
    modelSetup.setupStackServiceComponent();
    if (selectedServiceNames.contains('GLUSTERFS')) allServices.push('GLUSTERFS');
    allServices = allServices.map(function(serviceName) {
      return [App.StackService.createRecord({
        'serviceName': serviceName,
        'isSelected': false,
        'canBeSelected': true,
        'isInstalled': false,
        isPrimaryDFS: serviceName === 'HDFS',
        isDFS: ['HDFS','GLUSTERFS'].contains(serviceName),
        isMonitoringService: ['GANGLIA'].contains(serviceName),
        requiredServices: App.StackService.find(serviceName).get('requiredServices') || [],
        displayNameOnSelectServicePage: App.format.role(serviceName, true),
        coSelectedServices: function() {
          return App.StackService.coSelected[this.get('serviceName')] || [];
        }.property('serviceName')
      })];
    }).reduce(function(current, prev) { return current.concat(prev); });

    selectedServiceNames.forEach(function(serviceName) {
      allServices.findProperty('serviceName', serviceName).set('isSelected', true);
    });

    return allServices;
  };

  describe('#isSubmitDisabled', function () {
    it('should return false if at least one selected service is not installed', function () {
      expect(controller.get('isSubmitDisabled')).to.equal(false);
    });
    it('should return true if all selected services are already installed', function () {
      controller.setEach('isInstalled', true);
      controller.findProperty('serviceName', 'HDFS').set('isSelected', false);
      expect(controller.get('isSubmitDisabled')).to.equal(true);
    });
  });

  describe('#isAllChecked', function () {
    it('should return true if all non DFS services are selected', function () {
      controller.setEach('isInstalled', false);
      controller.findProperty('serviceName', 'YARN').set('isSelected', true);
      controller.findProperty('serviceName', 'HDFS').set('isSelected', false);
      expect(controller.get('isAllChecked')).to.equal(true);
    });

    it('should return false if at least one service is not selected', function () {
      controller.findProperty('serviceName', 'YARN').set('isSelected', false);
      expect(controller.get('isAllChecked')).to.equal(false);
    });
  });

  describe('#fileSystems', function () {
    beforeEach(function () {
      controller.clear();
      controller.set('content', generateSelectedServicesContent(['HDFS', 'GLUSTERFS', 'YARN']));
    });

    it('returns only DFS services', function () {
      expect(controller.get('fileSystems')).to.have.length(2);
      expect(controller.get('fileSystems').mapProperty('serviceName')).to.contain('GLUSTERFS');
      expect(controller.get('fileSystems').mapProperty('serviceName')).to.contain('HDFS');
    });

    it('allows selecting only one DFS at a time', function () {
      var fileSystems = controller.get('fileSystems');
      fileSystems[0].set('isSelected', true);
      expect(fileSystems[0].get('isSelected')).to.equal(true);
      expect(fileSystems[1].get('isSelected')).to.equal(false);
      fileSystems[1].set('isSelected', true);
      expect(fileSystems[0].get('isSelected')).to.equal(false);
      expect(fileSystems[1].get('isSelected')).to.equal(true);
    });
  });
  describe('#multipleDFSs()', function () {
    it('should return true if HDFS is selected and GLUSTERFS is selected', function () {
      controller.set('content', generateSelectedServicesContent(['HDFS', 'GLUSTERFS']));
      expect(controller.multipleDFSs()).to.equal(true);
    });
    it('should return false if HDFS is not selected and GLUSTERFS is selected', function () {
      controller.set('content', generateSelectedServicesContent(['GLUSTERFS']));
      expect(controller.multipleDFSs()).to.equal(false);
    });
    it('should return false if HDFS is selected and GLUSTERFS is not selected', function () {
      controller.set('content', generateSelectedServicesContent(['HDFS']));
      expect(controller.multipleDFSs()).to.equal(false);
    });
  });

  describe('#setGroupedServices()', function () {
    var testCases = [
      {
        title: 'should set MapReduce2 isSelected to true when YARN is selected',
        condition: {
          'YARN': true,
          'HBASE': true,
          'ZOOKEEPER': true,
          'HIVE': true,
          'MAPREDUCE2': true
        },
        result: {
          'MAPREDUCE2': true
        }
      },
      {
        title: 'should set MapReduce2 isSelected to false when YARN is not selected',
        condition: {
          'YARN': false,
          'HBASE': true,
          'ZOOKEEPER': true,
          'HIVE': false,
          'MAPREDUCE2': true
        },
        result: {
          'MAPREDUCE2': false
        }
      },
      {
        title: 'should set MAPREDUCE2 isSelected to true when YARN is selected',
        condition: {
          'HBASE': true,
          'ZOOKEEPER': true,
          'HIVE': false,
          'YARN': true,
          'MAPREDUCE2': true
        },
        result: {
          'MAPREDUCE2': true
        }
      },
      {
        title: 'should set MAPREDUCE2 isSelected to false when YARN is not selected',
        condition: {
          'HBASE': true,
          'ZOOKEEPER': true,
          'HIVE': true,
          'YARN': false,
          'MAPREDUCE2': true
        },
        result: {
          'MAPREDUCE2': false
        }
      }
    ];

    testCases.forEach(function(testCase){
      describe(testCase.title, function () {

        beforeEach(function () {
          controller.clear();
          Object.keys(testCase.condition).forEach(function (id) {
            controller.pushObject(App.StackService.createRecord({
              serviceName: id,
              isSelected: testCase.condition[id],
              canBeSelected: true,
              isInstalled: false,
              coSelectedServices: function() {
                return App.StackService.coSelected[this.get('serviceName')] || [];
              }.property('serviceName')
            }));
          });
          controller.setGroupedServices();
        });

        Object.keys(testCase.result).forEach(function (service) {
          it(service, function () {
            expect(controller.findProperty('serviceName', service).get('isSelected')).to.equal(testCase.result[service]);
          });
        });
      });
    }, this);
  });

  describe('#addValidationError()', function() {
    var tests = [
      {
        errorObjects: [
          {
            id: 'serviceCheck_ZOOKEEPER',
            shouldBeAdded: true
          },
          {
            id: 'serviceCheck_YARN',
            shouldBeAdded: true
          }
        ],
        expectedIds: ['serviceCheck_ZOOKEEPER', 'serviceCheck_YARN']
      },
      {
        errorObjects: [
          {
            id: 'fsCheck',
            shouldBeAdded: true
          },
          {
            id: 'fsCheck',
            shouldBeAdded: false
          }
        ],
        expectedIds: ['fsCheck']
      }
    ];

    beforeEach(function() {
      controller.clear();
      controller.set('errorStack', []);
    });

    tests.forEach(function(test) {
      var message = 'Erorrs {0} thrown. errorStack property should contains ids: {1}'
        .format(test.errorObjects.mapProperty('id').join(', '), test.expectedIds.join(', '));
      describe(message, function() {

        beforeEach(function () {
          this.added = [];
          test.errorObjects.forEach(function(errorObject) {
            this.added.push(controller.addValidationError(errorObject));
          }, this);
        });

        it('shouldBeAdded', function() {
          expect(this.added).to.be.eql(test.errorObjects.mapProperty('shouldBeAdded'));
        });

        it('expectedIds', function() {
          expect(controller.get('errorStack').mapProperty('id')).to.eql(test.expectedIds);
        });
      });
    })
  });

  describe('#validate()', function() {
    var tests = [
        {
          services: ['HDFS', 'ZOOKEEPER'],
          errorsExpected: ['ambariMetricsCheck', 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['ZOOKEEPER'],
          errorsExpected: ['ambariMetricsCheck', 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS'],
          errorsExpected: ['serviceCheck_ZOOKEEPER', 'ambariMetricsCheck', 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS', 'TEZ', 'ZOOKEEPER'],
          errorsExpected: ['serviceCheck_YARN', 'ambariMetricsCheck' , 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS', 'ZOOKEEPER', 'FALCON'],
          errorsExpected: ['serviceCheck_OOZIE', 'ambariMetricsCheck' , 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS', 'ZOOKEEPER', 'GANGLIA', 'HIVE'],
          errorsExpected: ['serviceCheck_YARN', 'ambariMetricsCheck' , 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS', 'GLUSTERFS', 'ZOOKEEPER', 'HIVE'],
          errorsExpected: ['serviceCheck_YARN', 'multipleDFS', 'ambariMetricsCheck', 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS','ZOOKEEPER', 'GANGLIA'],
          errorsExpected: ['ambariMetricsCheck', 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS','ZOOKEEPER', 'AMBARI_METRICS'],
          errorsExpected: ['smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['ZOOKEEPER', 'AMBARI_METRICS'],
          errorsExpected: ['smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS', 'AMBARI_METRICS'],
          errorsExpected: ['serviceCheck_ZOOKEEPER', 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS', 'TEZ', 'ZOOKEEPER', 'AMBARI_METRICS'],
          errorsExpected: ['serviceCheck_YARN', 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS', 'ZOOKEEPER', 'FALCON', 'AMBARI_METRICS'],
          errorsExpected: ['serviceCheck_OOZIE', 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS', 'ZOOKEEPER', 'GANGLIA', 'HIVE', 'AMBARI_METRICS'],
          errorsExpected: ['serviceCheck_YARN', 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS', 'GLUSTERFS', 'ZOOKEEPER', 'HIVE', 'AMBARI_METRICS'],
          errorsExpected: ['serviceCheck_YARN', 'multipleDFS', 'smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['HDFS','ZOOKEEPER', 'GANGLIA', 'AMBARI_METRICS'],
          errorsExpected: ['smartSenseCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['RANGER'],
          errorsExpected: ['ambariMetricsCheck', 'smartSenseCheck', 'atlasCheck', 'ambariRangerInfraCheck']
        },
        {
          services: ['SMARTSENSE'],
          errorsExpected: ['ambariMetricsCheck', 'rangerCheck', 'atlasCheck']
        },
        {
          services: ['ATLAS', 'AMBARI_METRICS', 'SMARTSENSE'],
          errorsExpected: ['rangerCheck', 'ambariAtlasInfraCheck', 'ambariAtlasHbaseCheck']
        },
        {
          services: ['LOGSEARCH', 'AMBARI_METRICS', 'SMARTSENSE'],
          errorsExpected: ['rangerCheck', 'atlasCheck', 'ambariLogsearchCheck']
        },
        {
          services: ['ATLAS', 'AMBARI_METRICS', 'SMARTSENSE', 'RANGER'],
          errorsExpected: ['ambariRangerInfraCheck', 'ambariAtlasInfraCheck', 'ambariAtlasHbaseCheck']
        },
      ],
      controllerNames = ['installerController', 'addServiceController'],
      wizardNames = {
        installerController: 'Install Wizard',
        addServiceController: 'Add Service Wizard'
      },
      sparkCases = [
        {
          currentStackName: 'HDP',
          currentStackVersionNumber: '2.2',
          sparkWarningExpected: true,
          title: 'HDP 2.2'
        },
        {
          currentStackName: 'HDP',
          currentStackVersionNumber: '2.3',
          sparkWarningExpected: false,
          title: 'HDP 2.3'
        },
        {
          currentStackName: 'BIGTOP',
          currentStackVersionNumber: '0.8',
          sparkWarningExpected: false,
          title: 'Non-HDP stack'
        }
      ];

    beforeEach(function () {
      controller.clear();
    });

    controllerNames.forEach(function (name) {
      tests.forEach(function(test) {
        var errorsExpected = test.errorsExpected;
        if (name !== 'installerController') {
          errorsExpected = test.errorsExpected.without('ambariMetricsCheck').without('smartSenseCheck').without('rangerCheck').without('atlasCheck');
        }
        var message = '{0}, {1} selected validation should be {2}, errors: {3}'
          .format(wizardNames[name], test.services.join(','), errorsExpected.length ? 'passed' : 'failed',
            errorsExpected.length ? errorsExpected.join(',') : 'absent');
        it(message, function() {
          controller.setProperties({
            content: generateSelectedServicesContent(test.services),
            errorStack: [],
            wizardController: Em.Object.create({
              name: name
            })
          });
          controller.validate();
          expect(controller.get('errorStack').mapProperty('id')).to.eql(errorsExpected.toArray());
        });
      })
    });

    sparkCases.forEach(function (item) {
      describe(item.title, function () {

        beforeEach(function () {
          sinon.stub(App, 'get').withArgs('currentStackName').returns(item.currentStackName).
            withArgs('currentStackVersionNumber').returns(item.currentStackVersionNumber);
          controller.set('errorStack', []);
          controller.set('content', generateSelectedServicesContent(['SPARK']));
          controller.validate();
        });

        afterEach(function () {
          App.get.restore();
        });

        it('sparkWarning ' + (item.sparkWarningExpected ? 'exists' : 'not exists'), function () {
          expect(controller.get('errorStack').someProperty('id', 'sparkWarning')).to.equal(item.sparkWarningExpected);
        });
      });
    });

  });

  describe('#onPrimaryPopupCallback()', function() {
    var c;
    var tests = [
      {
        services: ['HDFS','ZOOKEEPER'],
        confirmPopupCount: 0,
        errorsExpected: []
      },
      {
        services: ['ZOOKEEPER'],
        confirmPopupCount: 0,
        errorsExpected: []
      },
      {
        services: ['HDFS', 'GLUSTERFS', 'ZOOKEEPER', 'HIVE'],
        confirmPopupCount: 2,
        errorsExpected: ['serviceCheck_YARN', 'serviceCheck_TEZ', 'multipleDFS']
      },
      {
        services: ['HDFS','ZOOKEEPER', 'GANGLIA'],
        confirmPopupCount: 0,
        errorsExpected: []
      }
    ];

    beforeEach(function() {
      c = App.WizardStep4Controller.create({});
      sinon.stub(App.router, 'send', Em.K);
      sinon.stub(c, 'submit', Em.K);
      sinon.spy(c, 'onPrimaryPopupCallback');
    });

    afterEach(function() {
      App.router.send.restore();
      c.submit.restore();
      c.onPrimaryPopupCallback.restore();
    });


    tests.forEach(function(test) {
      var message = 'Selected services: {0}. {1} errors should be confirmed'
        .format(test.services.join(', '), test.confirmPopupCount);

      describe(message, function() {
        var runValidations = function() {
          c.serviceDependencyValidation();
          c.fileSystemServiceValidation();
        };

        beforeEach(function () {
          c.set('content', generateSelectedServicesContent(test.services));
          runValidations();
        });

        it('errors count validation', function () {
          expect(c.get('errorStack.length')).to.equal(test.confirmPopupCount);
        });

        if (test.errorsExpected) {
          describe('if errors detected than it should be shown', function () {
            var currentErrorObject;
            beforeEach(function () {
              currentErrorObject = c.get('errorStack').findProperty('isShown', false);
            });
            test.errorsExpected.forEach(function(error) {
              it(error, function () {
                // validate current error
                if (currentErrorObject) {
                  expect(test.errorsExpected).to.contain(currentErrorObject.id);
                  // show current error
                  var popup = c.showError(currentErrorObject);
                  // submit popup
                  popup.onPrimary();
                  // onPrimaryPopupCallback should be called
                  expect(c.onPrimaryPopupCallback.called).to.equal(true);
                  // submit called
                  expect(c.submit.called).to.equal(true);
                  if (c.get('errorStack').length) {
                    // current error isShown flag changed to true
                    expect(currentErrorObject.isShown).to.equal(true);
                  }
                  runValidations();
                }
              });
            });
          });
        }
      });
    });

  });

  describe('#needToAddServicePopup', function() {

    beforeEach(function () {
      sinon.stub(controller, 'submit', Em.K);
    });

    afterEach(function () {
      controller.submit.restore();
    });

    Em.A([
        {
          m: 'one service',
          services: {selected: true, serviceName: 's1'},
          content: [Em.Object.create({serviceName: 's1', isSelected: false})],
          e: [true]
        },
        {
          m: 'many services',
          services: [{selected: true, serviceName: 's1'}, {selected: false, serviceName: 's2'}],
          content: [Em.Object.create({serviceName: 's1', isSelected: false}),
            Em.Object.create({serviceName: 's2', isSelected: true})],
          e: [true, false]
        }
      ]).forEach(function (test) {
        it(test.m, function () {
          controller.set('content', test.content);
          controller.needToAddServicePopup(test.services, '').onPrimary();
          expect(controller.submit.calledOnce).to.equal(true);
          expect(controller.mapProperty('isSelected')).to.eql(test.e);
        });
      });
  });

  describe('#submit', function() {
    var c;
    var tests = [
      {
        isSubmitDisabled: true,
        validate: false,
        userCanProceed: false
      },
      {
        isSubmitDisabled: false,
        validate: false,
        userCanProceed: false
      },
      {
        isSubmitDisabled: false,
        validate: true,
        userCanProceed: true
      }
    ];

    beforeEach(function() {
      c = App.WizardStep4Controller.create();
      sinon.stub(App.router, 'send', Em.K);
    });

    afterEach(function() {
      App.router.send.restore();
    });

    tests.forEach(function(test) {
      var messageFormat = [
        test.isSubmitDisabled ? 'disabled' : 'enabled',
        test.validate ? 'success' : 'failed',
        test.userCanProceed ? '' : 'not'
      ];
      var message = String.prototype.format.apply('Submit btn: {0}. Validation: {1}. Can{2} move to the next step.', messageFormat);

      it(message, function() {
        c.reopen({
          isSubmitDisabled: test.isSubmitDisabled,
          validate: function() { return test.validate; }
        });
        c.clear();
        c.submit();

        expect(App.router.send.calledOnce).to.equal(test.userCanProceed);
      });

    })
  });

  describe('#dependencies', function() {
    var tests = [
      {
        services: ['HDFS'],
        dependencies: ['ZOOKEEPER']
      },
      {
        services: ['STORM'],
        dependencies: ['ZOOKEEPER']
      }
    ];
    tests.forEach(function(test) {
      var message = '{0} dependency should be {1}'.format(test.services.join(','), test.dependencies.join(','));
      it(message, function() {

        controller.clear();
        controller.set('content', generateSelectedServicesContent(test.services));

        var dependentServicesTest = [];

        test.services.forEach(function(serviceName) {
          var service = controller.filterProperty('serviceName', serviceName);
          service.forEach(function(item) {
            var dependencies = item.get('requiredServices');
            if(!!dependencies) {
              dependentServicesTest = dependentServicesTest.concat(dependencies);
            }
          });
        });

        expect(dependentServicesTest).to.be.eql(test.dependencies);
      });
    })
  });

  describe('#serviceDependencyValidation', function () {

    var cases = [
      {
        services: ['HBASE'],
        dependentServices: ['HDFS', 'ZOOKEEPER'],
        title: 'HBASE selected and HDFS not selected initially'
      },
      {
        services: ['TEZ', 'HDFS'],
        dependentServices: ['ZOOKEEPER', 'YARN'],
        title: 'TEZ selected and ZOOKEEPER not selected initially'
      }
    ];

    beforeEach(function() {
      controller.clear();
      controller.set('errorStack', []);
    });

    cases.forEach(function (item) {
      describe(item.title, function () {

        beforeEach(function () {
          controller.set('content', generateSelectedServicesContent(item.services));
          controller.serviceDependencyValidation();
        });

        it('check errors in the stack', function () {
          var ids = controller.get('errorStack').mapProperty('id');
          expect(ids.contains("serviceCheck_" + item.dependentServices[0])).to.be.true;
          expect(ids.contains("serviceCheck_" + item.dependentServices[1])).to.be.true;
        });

        it('simulate situation where user clicks cancel on error for first dependent service and then selects it in which case', function () {
          controller.findProperty('serviceName', item.dependentServices[0]).set('isSelected', true);
          //serviceDependencyValidation() will be called again
          controller.serviceDependencyValidation();
          //error for first dependent service must be removed from errorStack array
          var ids = controller.get('errorStack').mapProperty('id');
          expect(ids.contains("serviceCheck_" + item.dependentServices[0])).to.be.false;
          expect(ids.contains("serviceCheck_" + item.dependentServices[1])).to.be.true;
        });

      });
    });
  });

  describe('#serviceValidation', function () {

    var cases = [
      {
        services: ['HDFS'],
        isAmbariMetricsWarning: false,
        title: 'Ambari Metrics not available'
      },
      {
        services: ['AMBARI_METRICS'],
        isAmbariMetricsSelected: false,
        isAmbariMetricsWarning: true,
        title: 'Ambari Metrics not selected'
      },
      {
        services: ['AMBARI_METRICS'],
        isAmbariMetricsSelected: true,
        isAmbariMetricsWarning: false,
        title: 'Ambari Metrics selected'
      }
    ];

    beforeEach(function() {
      controller.clear();
      controller.set('errorStack', []);
    });

    cases.forEach(function (item) {
      it(item.title, function () {
        controller.set('content', generateSelectedServicesContent(item.services));
        var ams = controller.findProperty('serviceName', 'AMBARI_METRICS');
        if (item.services.contains('AMBARI_METRICS')) {
          ams.set('isSelected', item.isAmbariMetricsSelected);
        } else {
          controller.removeObject(ams);
        }
        controller.serviceValidation(Em.K, 'AMBARI_METRICS', 'ambariMetricsCheck');
        expect(controller.get('errorStack').mapProperty('id').contains('ambariMetricsCheck')).to.equal(item.isAmbariMetricsWarning);
      });
    });

  });

  describe('#sparkValidation', function () {

    var cases = [
      {
        services: ['HDFS'],
        isSparkWarning: false,
        currentStackName: 'HDP',
        currentStackVersionNumber: '2.2',
        title: 'HDP 2.2, Spark not available'
      },
      {
        services: ['HDFS'],
        isSparkWarning: false,
        currentStackName: 'HDP',
        currentStackVersionNumber: '2.3',
        title: 'HDP 2.3, Spark not available'
      },
      {
        services: ['HDFS'],
        isSparkWarning: false,
        currentStackName: 'BIGTOP',
        currentStackVersionNumber: '0.8',
        title: 'Non-HDP stack, Spark not available'
      },
      {
        services: ['SPARK'],
        isSparkSelected: false,
        isSparkInstalled: false,
        isSparkWarning: false,
        currentStackName: 'HDP',
        currentStackVersionNumber: '2.2',
        title: 'HDP 2.2, Spark not selected'
      },
      {
        services: ['SPARK'],
        isSparkSelected: true,
        isSparkInstalled: false,
        isSparkWarning: true,
        currentStackName: 'HDP',
        currentStackVersionNumber: '2.2',
        title: 'HDP 2.2, Spark selected'
      },
      {
        services: ['SPARK'],
        isSparkSelected: true,
        isSparkInstalled: true,
        isSparkWarning: false,
        currentStackName: 'HDP',
        currentStackVersionNumber: '2.2',
        title: 'HDP 2.2, Spark installed'
      },
      {
        services: ['SPARK'],
        isSparkSelected: false,
        isSparkInstalled: false,
        isSparkWarning: false,
        currentStackName: 'HDP',
        currentStackVersionNumber: '2.3',
        title: 'HDP 2.3, Spark not selected'
      },
      {
        services: ['SPARK'],
        isSparkSelected: true,
        isSparkInstalled: false,
        isSparkWarning: false,
        currentStackName: 'HDP',
        currentStackVersionNumber: '2.3',
        title: 'HDP 2.3, Spark selected'
      },
      {
        services: ['SPARK'],
        isSparkSelected: true,
        isSparkInstalled: true,
        isSparkWarning: false,
        currentStackName: 'HDP',
        currentStackVersionNumber: '2.3',
        title: 'HDP 2.3, Spark installed'
      },
      {
        services: ['SPARK'],
        isSparkSelected: false,
        isSparkInstalled: false,
        isSparkWarning: false,
        currentStackName: 'BIGTOP',
        currentStackVersionNumber: '0.8',
        title: 'Non-HDP stack, Spark not selected'
      },
      {
        services: ['SPARK'],
        isSparkSelected: true,
        isSparkInstalled: false,
        isSparkWarning: false,
        currentStackName: 'BIGTOP',
        currentStackVersionNumber: '0.8',
        title: 'Non-HDP stack, Spark selected'
      },
      {
        services: ['SPARK'],
        isSparkSelected: true,
        isSparkInstalled: true,
        isSparkWarning: false,
        currentStackName: 'BIGTOP',
        currentStackVersionNumber: '0.8',
        title: 'Non-HDP stack, Spark installed'
      }
    ];

    beforeEach(function() {
      controller.clear();
      controller.set('errorStack', []);
      this.stub = sinon.stub(App, 'get');
    });

    afterEach(function () {
      App.get.restore();
    });

    cases.forEach(function (item) {
      describe(item.title, function () {
        beforeEach(function () {
          this.stub.withArgs('currentStackName').returns(item.currentStackName).
            withArgs('currentStackVersionNumber').returns(item.currentStackVersionNumber);
          controller.set('content', generateSelectedServicesContent(item.services));
          var spark = controller.findProperty('serviceName', 'SPARK');
          if (item.services.contains('SPARK')) {
            spark.setProperties({
              isSelected: item.isSparkSelected,
              isInstalled: item.isSparkInstalled
            });
          } else {
            controller.removeObject(spark);
          }
          controller.sparkValidation();
        });

        it('sparkWarning is ' + item.sparkWarning, function () {
          expect(controller.get('errorStack').mapProperty('id').contains('sparkWarning')).to.equal(item.isSparkWarning);
        });
      });
    });

  });

  describe('#clearErrors', function () {

    var cases = [
      {
        errorStack: [{
          isAccepted: false
        }],
        resultingErrorStack: [{
          isAccepted: false
        }],
        title: 'error stack shouldn\'t be cleared during validation'
      },
      {
        errorStack: [{
          isAccepted: true
        }],
        resultingErrorStack: [],
        title: 'error stack should be cleared'
      }
    ];

    beforeEach(function () {
      controller.set('errorStack', [{}]);
    });

    cases.forEach(function (item) {
      it(item.title, function () {
        controller.set('errorStack', item.errorStack);
        controller.propertyDidChange('@each.isSelected');
        expect(controller.get('errorStack')).to.eql(item.resultingErrorStack);
      });
    });

  });

  describe('Service warnings popup', function () {

    var target = {
      clb: Em.K
    };
    var id = 1;

    beforeEach(function () {
      sinon.spy(target, 'clb');
      sinon.stub(controller, 'onPrimaryPopupCallback', Em.K);
    });

    afterEach(function () {
      target.clb.restore();
      controller.onPrimaryPopupCallback.restore();
    });

    Em.A([
      'serviceCheckPopup',
      'sparkWarningPopup'
    ]).forEach(function (methodName) {

      describe('#' + methodName, function () {

        beforeEach(function () {
          this.popup = controller[methodName](target.clb, id);
        });

        it('#onPrimary', function () {
          this.popup.onPrimary();
          expect(controller.onPrimaryPopupCallback.calledWith(target.clb)).to.be.true;
        });

        it('#onSecondary', function () {
          this.popup.onSecondary();
          expect(target.clb.calledWith(id)).to.be.true;
        });

        it('#onClose', function () {
          this.popup.onClose();
          expect(target.clb.calledWith(id)).to.be.true;
        });
      });
    });
  });

  describe('#dependentServiceValidation', function() {

    beforeEach(function() {
      sinon.stub(controller, 'serviceValidation');
    });

    afterEach(function() {
      controller.serviceValidation.restore();
      controller.clear();
    });

    it('serviceValidation should not be called when selected service does not exist', function() {
      controller.dependentServiceValidation('S1', 'S2', 'check', Em.K);
      expect(controller.serviceValidation.called).to.be.false;
    });

    it('serviceValidation should not be called when service not selected', function() {
      controller.pushObject(App.StackService.createRecord({
        serviceName: 'S1',
        isSelected: false
      }));
      controller.dependentServiceValidation('S1', 'S2', 'check', Em.K);
      expect(controller.serviceValidation.called).to.be.false;
    });

    it('serviceValidation should not be called when dependent service does not exist', function() {
      controller.pushObjects([
        App.StackService.createRecord({
          serviceName: 'S1',
          isSelected: true
        })
      ]);
      controller.dependentServiceValidation('S1', 'S2', 'check', Em.K);
      expect(controller.serviceValidation.called).to.be.false;
    });

    it('serviceValidation should not be called when dependent service is selected', function() {
      controller.pushObjects([
        App.StackService.createRecord({
          serviceName: 'S1',
          isSelected: true
        }),
        Em.Object.create({
          serviceName: 'S2',
          isSelected: true
        })
      ]);
      controller.dependentServiceValidation('S1', 'S2', 'check', Em.K);
      expect(controller.serviceValidation.called).to.be.false;
    });

    it('serviceValidation should be called when dependent service is not selected', function() {
      controller.pushObjects([
        App.StackService.createRecord({
          serviceName: 'S1',
          isSelected: true
        }),
        Em.Object.create({
          serviceName: 'S2',
          isSelected: false
        })
      ]);
      controller.dependentServiceValidation('S1', 'S2', 'check', Em.K);
      expect(controller.serviceValidation.calledOnce).to.be.true;
    });
  });

});