# 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 File.expand_path("../../spec_helper", __FILE__)
require "fog/aws"

describe Chef::Knife::Ec2ServerDelete do
  before do
  end

  describe "run" do
    before(:each) do
      {
        image: "image",
        ssh_key_name: "ssh_key_name",
        aws_access_key_id: "aws_access_key_id",
        aws_secret_access_key: "aws_secret_access_key",
      }.each do |key, value|
        Chef::Config[:knife][key] = value
      end

      @ec2_server_attribs = { id: "i-39382318",
                              flavor_id: "m1.small",
                              image_id: "ami-47241231",
                              availability_zone: "us-west-1",
                              key_name: "my_ssh_key",
                              groups: %w{group1 group2},
                              security_group_ids: ["sg-00aa11bb"],
                              dns_name: "ec2-75.101.253.10.compute-1.amazonaws.com",
                              iam_instance_profile: {},
                              public_ip_address: "75.101.253.10",
                              private_dns_name: "ip-10-251-75-20.ec2.internal",
                              private_ip_address: "10.251.75.20",
                              root_device_type: "not_ebs",
                              tags: { "Name" => "foo" },
                            }
      @knife_ec2_delete = Chef::Knife::Ec2ServerDelete.new
      @ec2_servers = double()
      allow(@knife_ec2_delete.ui).to receive(:confirm)
      allow(@knife_ec2_delete).to receive(:msg_pair)
      @ec2_server = double(@ec2_server_attribs)
      @ec2_connection = double(Fog::Compute::AWS)
      allow(@ec2_connection).to receive(:servers).and_return(@ec2_servers)
      allow(@knife_ec2_delete.ui).to receive(:warn)
    end

    it "should invoke validate!" do
      knife_ec2_delete = Chef::Knife::Ec2ServerDelete.new
      expect(knife_ec2_delete).to receive(:validate!)
      knife_ec2_delete.run
    end

    it "should use invoke fog api to delete instance if instance id is passed" do
      expect(@ec2_servers).to receive(:get).with("foo").and_return(@ec2_server)
      expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
      @knife_ec2_delete.name_args = ["foo"]
      expect(@knife_ec2_delete).to receive(:validate!)
      expect(@ec2_server).to receive(:destroy)
      @knife_ec2_delete.run
    end

    it "should use node_name to figure out instance id if not specified explicitly" do
      expect(@ec2_servers).to receive(:get).with("foo").and_return(@ec2_server)
      expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
      expect(@knife_ec2_delete).to receive(:validate!)
      expect(@ec2_server).to receive(:destroy)
      @knife_ec2_delete.config[:purge] = false
      @knife_ec2_delete.config[:chef_node_name] = "baz"
      double_node = double(Chef::Node)
      expect(double_node).to receive(:attribute?).with("ec2").and_return(true)
      expect(double_node).to receive(:[]).with("ec2").and_return("instance_id" => "foo")
      double_search = double(Chef::Search::Query)
      expect(double_search).to receive(:search).with(:node, "name:baz").and_return([[double_node], nil, nil])
      expect(Chef::Search::Query).to receive(:new).and_return(double_search)
      @knife_ec2_delete.name_args = []
      @knife_ec2_delete.run
    end

    describe "when --purge is passed" do
      it "should use the node name if its set" do
        expect(@ec2_servers).to receive(:get).with("foo").and_return(@ec2_server)
        expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
        @knife_ec2_delete.name_args = ["foo"]
        expect(@knife_ec2_delete).to receive(:validate!)
        expect(@ec2_server).to receive(:destroy)
        @knife_ec2_delete.config[:purge] = true
        @knife_ec2_delete.config[:chef_node_name] = "baz"
        expect(Chef::Node).to receive(:load).with("baz").and_return(double(destroy: true))
        expect(Chef::ApiClient).to receive(:load).with("baz").and_return(double(destroy: true))
        @knife_ec2_delete.run
      end

      it "should search for the node name using the instance id when node name is not specified" do
        expect(@ec2_servers).to receive(:get).with("i-foo").and_return(@ec2_server)
        expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
        @knife_ec2_delete.name_args = ["i-foo"]
        expect(@knife_ec2_delete).to receive(:validate!)
        expect(@ec2_server).to receive(:destroy)
        @knife_ec2_delete.config[:purge] = true
        @knife_ec2_delete.config[:chef_node_name] = nil
        double_search = double(Chef::Search::Query)
        double_node = double(Chef::Node)
        expect(double_node).to receive(:name).and_return("baz")
        expect(Chef::Node).to receive(:load).with("baz").and_return(double(destroy: true))
        expect(Chef::ApiClient).to receive(:load).with("baz").and_return(double(destroy: true))
        expect(double_search).to receive(:search).with(:node, "ec2_instance_id:i-foo").and_return([[double_node], nil, nil])
        expect(Chef::Search::Query).to receive(:new).and_return(double_search)
        @knife_ec2_delete.run
      end

      it "should use  the instance id if search does not return anything" do
        expect(@ec2_servers).to receive(:get).with("i-foo").and_return(@ec2_server)
        expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
        @knife_ec2_delete.name_args = ["i-foo"]
        expect(@knife_ec2_delete).to receive(:validate!)
        expect(@ec2_server).to receive(:destroy)
        @knife_ec2_delete.config[:purge] = true
        @knife_ec2_delete.config[:chef_node_name] = nil
        expect(Chef::Node).to receive(:load).with("i-foo").and_return(double(destroy: true))
        expect(Chef::ApiClient).to receive(:load).with("i-foo").and_return(double(destroy: true))
        double_search = double(Chef::Search::Query)
        expect(double_search).to receive(:search).with(:node, "ec2_instance_id:i-foo").and_return([[], nil, nil])
        expect(Chef::Search::Query).to receive(:new).and_return(double_search)
        @knife_ec2_delete.run
      end
    end
  end
end