#
# Author:: Adam Jacob (<adam@opscode.com>)
# Copyright:: Copyright (c) 2008 Opscode, Inc.
# License:: Apache License, Version 2.0
#
# Licensed 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.
#

require 'spec_helper'
require 'chef/data_bag'

describe Chef::DataBag do
  before(:each) do
    @data_bag = Chef::DataBag.new
    allow(Chef::Platform)::to receive(:windows?) { false }
  end

  describe "initialize" do
    it "should be a Chef::DataBag" do
      expect(@data_bag).to be_a_kind_of(Chef::DataBag)
    end
  end

  describe "name" do
    it "should let you set the name to a string" do
      expect(@data_bag.name("clowns")).to eq("clowns")
    end

    it "should return the current name" do
      @data_bag.name "clowns"
      expect(@data_bag.name).to eq("clowns")
    end

    it "should not accept spaces" do
      expect { @data_bag.name "clown masters" }.to raise_error(ArgumentError)
    end

    it "should throw an ArgumentError if you feed it anything but a string" do
      expect { @data_bag.name Hash.new }.to raise_error(ArgumentError)
    end

    [ ".", "-", "_", "1"].each do |char|
      it "should allow a '#{char}' character in the data bag name" do
        expect(@data_bag.name("clown#{char}clown")).to eq("clown#{char}clown")
      end
    end
  end

  describe "deserialize" do
    before(:each) do
      @data_bag.name('mars_volta')
      @deserial = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@data_bag))
    end

    it "should deserialize to a Chef::DataBag object" do
      expect(@deserial).to be_a_kind_of(Chef::DataBag)
    end

    %w{
      name
    }.each do |t|
      it "should match '#{t}'" do
        expect(@deserial.send(t.to_sym)).to eq(@data_bag.send(t.to_sym))
      end

      include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
        let(:jsonable) { @data_bag }
      end
    end

  end

  describe "when saving" do
    before do
      @data_bag.name('piggly_wiggly')
      @rest = double("Chef::REST")
      allow(Chef::REST).to receive(:new).and_return(@rest)
    end

    it "should silently proceed when the data bag already exists" do
      exception = double("409 error", :code => "409")
      expect(@rest).to receive(:post_rest).and_raise(Net::HTTPServerException.new("foo", exception))
      @data_bag.save
    end

    it "should create the data bag" do
      expect(@rest).to receive(:post_rest).with("data", @data_bag)
      @data_bag.save
    end

    describe "when whyrun mode is enabled" do
      before do
        Chef::Config[:why_run] = true
      end
      after do
        Chef::Config[:why_run] = false
      end
      it "should not save" do
        expect(@rest).not_to receive(:post_rest)
        @data_bag.save
      end
    end

  end
  describe "when loading" do
    describe "from an API call" do
      before do
        Chef::Config[:chef_server_url] = 'https://myserver.example.com'
        @http_client = double('Chef::REST')
      end

      it "should get the data bag from the server" do
        expect(Chef::REST).to receive(:new).with('https://myserver.example.com').and_return(@http_client)
        expect(@http_client).to receive(:get_rest).with('data/foo')
        Chef::DataBag.load('foo')
      end

      it "should return the data bag" do
        allow(Chef::REST).to receive(:new).and_return(@http_client)
        expect(@http_client).to receive(:get_rest).with('data/foo').and_return({'bar' => 'https://myserver.example.com/data/foo/bar'})
        data_bag = Chef::DataBag.load('foo')
        expect(data_bag).to eq({'bar' => 'https://myserver.example.com/data/foo/bar'})
      end
    end

    def file_dir_stub(path, returns = true)
      expect(File).to receive(:directory?).with(path).and_return(returns)
    end

    def dir_glob_stub(path, returns = [])
      expect(Dir).to receive(:glob).with(File.join(path, 'foo/*.json')).and_return(returns)
    end

    shared_examples_for "data bag in solo mode" do |data_bag_path|
      before do
        Chef::Config[:solo] = true
        Chef::Config[:data_bag_path] = data_bag_path
        @paths = Array(data_bag_path)
      end

      after do
        Chef::Config[:solo] = false
      end

      it "should get the data bag from the data_bag_path" do
        @paths.each do |path|
          file_dir_stub(path)
          dir_glob_stub(path)
        end
        Chef::DataBag.load('foo')
      end

      it "should get the data bag from the data_bag_path by symbolic name" do
        @paths.each do |path|
          file_dir_stub(path)
          dir_glob_stub(path)
        end
        Chef::DataBag.load(:foo)
      end

      it "should return the data bag" do
        @paths.each do |path|
          file_dir_stub(path)
          if path == @paths.first
            dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
          else
            dir_glob_stub(path)
          end
        end
        expect(IO).to receive(:read).with(File.join(@paths.first, 'foo/bar.json')).and_return('{"id": "bar", "name": "Bob Bar" }')
        expect(IO).to receive(:read).with(File.join(@paths.first, 'foo/baz.json')).and_return('{"id": "baz", "name": "John Baz" }')
        data_bag = Chef::DataBag.load('foo')
        expect(data_bag).to eq({ 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar' }, 'baz' => { 'id' => 'baz', 'name' => 'John Baz' }})
      end

      it "should raise if data bag has items with similar names but different content" do
        @paths.each do |path|
          file_dir_stub(path)
          item_with_different_content = "{\"id\": \"bar\", \"name\": \"Bob Bar\", \"path\": \"#{path}\"}"
          expect(IO).to receive(:read).with(File.join(path, 'foo/bar.json')).and_return(item_with_different_content)
          if data_bag_path.is_a?(String)
            dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
            item_2_with_different_content = '{"id": "bar", "name": "John Baz"}'
            expect(IO).to receive(:read).with(File.join(path, 'foo/baz.json')).and_return(item_2_with_different_content)
          else
            dir_glob_stub(path, [File.join(path, 'foo/bar.json')])
          end
        end
        expect { Chef::DataBag.load('foo') }.to raise_error(Chef::Exceptions::DuplicateDataBagItem)
      end

      it "should return data bag if it has items with similar names and the same content" do
        @paths.each do |path|
          file_dir_stub(path)
          dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
          item_with_same_content = '{"id": "bar", "name": "Bob Bar"}'
          expect(IO).to receive(:read).with(File.join(path, 'foo/bar.json')).and_return(item_with_same_content)
          expect(IO).to receive(:read).with(File.join(path, 'foo/baz.json')).and_return(item_with_same_content)
        end
        data_bag = Chef::DataBag.load('foo')
        test_data_bag = { 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar'} }
        expect(data_bag).to eq(test_data_bag)
      end

      it "should merge data bag items if there are no conflicts" do
        @paths.each_with_index do |path, index|
          file_dir_stub(path)
          dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
          test_item_with_same_content = '{"id": "bar", "name": "Bob Bar"}'
          expect(IO).to receive(:read).with(File.join(path, 'foo/bar.json')).and_return(test_item_with_same_content)
          test_uniq_item = "{\"id\": \"baz_#{index}\", \"name\": \"John Baz\", \"path\": \"#{path}\"}"
          expect(IO).to receive(:read).with(File.join(path, 'foo/baz.json')).and_return(test_uniq_item)
        end
        data_bag = Chef::DataBag.load('foo')
        test_data_bag = { 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar'} }
        @paths.each_with_index do |path, index|
          test_data_bag["baz_#{index}"] = { "id" => "baz_#{index}", "name" => "John Baz", "path" => path }
        end
        expect(data_bag).to eq(test_data_bag)
      end

      it "should return the data bag list" do
        @paths.each do |path|
          file_dir_stub(path)
          expect(Dir).to receive(:glob).and_return([File.join(path, 'foo'), File.join(path, 'bar')])
        end
        data_bag_list = Chef::DataBag.list
        expect(data_bag_list).to eq({ 'bar' => 'bar', 'foo' => 'foo' })
      end

      it 'should raise an error if the configured data_bag_path is invalid' do
        file_dir_stub(@paths.first, false)

        expect {
          Chef::DataBag.load('foo')
        }.to raise_error Chef::Exceptions::InvalidDataBagPath, "Data bag path '/var/chef/data_bags' is invalid"
      end

    end

    describe "data bag with string path" do
      it_should_behave_like "data bag in solo mode", "/var/chef/data_bags"
    end

    describe "data bag with array path" do
      it_should_behave_like "data bag in solo mode", ["/var/chef/data_bags", "/var/chef/data_bags_2"]
    end
  end

end
