require 'spec_helper'
require 'flydata/helper/config_parser'

module Flydata
  module Helper
    describe Config do
      context ".create" do
        subject { Config.create(config_hash) }
        context "initialized with empty hash" do
          let(:config_hash) { Hash.new }
          it "should return a config object and respond to dynamically added methods" do
            is_expected.not_to be_nil
            is_expected.to respond_to(:helper_home)
          end
          it "should return default values correctly" do
            expect(subject.helper_retry_limit).to eq(15)
          end
        end
        context "initialized with non-empty hash" do
          let(:override_helper_home) { "/home/user/.flydata/helper" }
          let(:config_hash) { {helper_home: override_helper_home} }
          it "should return correct value of a property" do
            expect(subject.helper_home).to eq(override_helper_home)
          end
        end
      end

      context '#scheduled_actions' do
        subject { Config.default }
        it "should return the scheduled actions correctly" do
          expect(subject.scheduled_actions).to eq({
            check_remote_actions:
              {
                check_interval: 30,
                name: :check_remote_actions
              },
            check_abnormal_shutdown:
              {
                check_interval: 60,
                name: :check_abnormal_shutdown
              }
          })
        end
        it "should return a copy everytime" do
          helper_config = subject
          src = helper_config[:scheduled_actions]
          copy = helper_config.scheduled_actions
          expect(src.object_id).not_to eq(copy.object_id)
          expect(src[:check_remote_actions].object_id).
            not_to eq(copy[:check_remote_actions].object_id)
        end
      end
    end

    describe ConfigParser do
      context ".parse" do
        subject { described_class.parse(conf_content)}
        context "when the parsed content is empty" do
          let(:conf_content) { "" }
          it "should raise an error" do
            expect { subject }.to raise_error
          end
        end
        context "when the parsed content does not contain scheduled action" do
          let(:conf_content) { "workers: 5" }
          it "should return the default scheduled action" do
            is_expected.to eq({
              workers: 5,
              helper: {
                scheduled_actions: {
                  check_remote_actions: {
                    check_interval: '30s'
                  },
                  check_abnormal_shutdown: {
                    check_interval: '60s'
                  }
                }
              }
            })
          end
        end
        context "when content includes scheduled action" do
          let(:conf_content) { <<EOT
workers: 2
helper:
  scheduled_actions:
    check_remote_actions:
      check_interval: 1m
EOT
          }
          it "should parse to a Config object" do
            is_expected.to eq({
              workers: 2,
              helper: {
                scheduled_actions: {
                  check_remote_actions: {
                    check_interval: '1m'
                  },
                  check_abnormal_shutdown: {
                    check_interval: '60s'
                  }
                }
              }
            })
          end
        end
      end
      describe ".parse_file" do
        subject { described_class.parse_file(path) }

        let(:expected_result) { double("expected_parse_result") }

        shared_examples "opening a conf file and parse the contents" do
          let(:conf_contents) { double("conf_contents") }
          let(:conf_file) { double("conf_file") }

          before do
            expect(File).to receive(:open).with(expected_path).
                            and_return(conf_file)
            expect(conf_file).to receive(:read).and_return(conf_contents)
            expect(described_class).to receive(:parse).with(conf_contents).
                                       and_return(expected_result)
          end
        end

        context "when path is given" do
          let(:path) { "/path/to/my/helper.conf" }
          let(:expected_path) { path }

          before do
            expect(File).to_not receive(:exists?)
          end
          include_examples "opening a conf file and parse the contents"
          it { is_expected.to eq(expected_result) }
        end
        context "when no path is given" do
          let(:path) { nil }
          let(:expected_path) { File.join(Flydata::FLYDATA_HELPER_HOME, "helper.conf") }

          context "and default conf file exists" do
            before do
              expect(File).to receive(:exists?).with(expected_path).
                              and_return true
            end
            include_examples "opening a conf file and parse the contents"
            it { is_expected.to eq(expected_result) }
          end
          context "and default conf file does not exist" do
            before do
              expect(File).to receive(:exists?).with(expected_path).
                              and_return false
            end
            let(:expected_result) { {
              helper: {
                scheduled_actions: {
                  check_remote_actions: { check_interval: "30s"},
                  check_abnormal_shutdown: {:check_interval=>"60s"}
                }
              }
            } }
            it { is_expected.to eq(expected_result) }
          end
        end
      end
    end
  end
end