require "spec_helper"

module Omnibus
  describe Packager::Solaris do
    let(:project) do
      Project.new.tap do |project|
        project.name("project")
        project.homepage("https://example.com")
        project.install_dir("/opt/project")
        project.build_version("1.2.3")
        project.build_iteration("1")
        project.maintainer("Chef Software")
      end
    end

    subject { described_class.new(project) }

    let(:project_root) { File.join(tmp_path, "project/root") }
    let(:package_dir)  { File.join(tmp_path, "package/dir") }
    let(:staging_dir)  { File.join(tmp_path, "staging/dir") }
    let(:architecture) { "i86pc" }

    before do
      # This is here to allow this unit test to run on windows.
      allow(File).to receive(:expand_path).and_wrap_original do |m, *args|
        m.call(*args).sub(/^[A-Za-z]:/, "")
      end
      Config.project_root(project_root)
      Config.package_dir(package_dir)

      allow(subject).to receive(:staging_dir).and_return(staging_dir)
      create_directory(staging_dir)

      stub_ohai(platform: "solaris2", version: "5.11") do |data|
        data["kernel"]["machine"] = architecture
      end
    end

    describe "#id" do
      it "is :solaris" do
        expect(subject.id).to eq(:solaris)
      end
    end

    describe "#package_name" do
      it "includes the name, version, iteration and architecture" do
        expect(subject.package_name).to eq("project-1.2.3-1.i386.solaris")
      end
    end

    describe "#pkgmk_version" do
      it "includes the version and iteration" do
        expect(subject.pkgmk_version).to eq("1.2.3-1")
      end
    end

    describe "#install_dirname" do
      it "returns the parent directory" do
        expect(subject.install_dirname).to eq("/opt")
      end
    end

    describe "#install_basename" do
      it "name of the install directory" do
        expect(subject.install_basename).to eq("project")
      end
    end

    describe "#write_scripts" do
      context "when scripts are given" do
        let(:scripts) { %w{ postinstall postremove } }
        before do
          scripts.each do |script_name|
            create_file("#{project_root}/package-scripts/project/#{script_name}") do
              "Contents of #{script_name}"
            end
          end
        end

        it "writes the scripts into scripts staging dir" do
          subject.write_scripts

          scripts.each do |script_name|
            script_file = "#{staging_dir}/#{script_name}"
            contents = File.read(script_file)
            expect(contents).to include("Contents of #{script_name}")
          end
        end
      end

      context "when scripts with default omnibus naming are given" do
        let(:default_scripts) { %w{ postinst postrm } }
        before do
          default_scripts.each do |script_name|
            create_file("#{project_root}/package-scripts/project/#{script_name}") do
              "Contents of #{script_name}"
            end
          end
        end

        it "writes the scripts into scripts staging dir" do
          subject.write_scripts

          default_scripts.each do |script_name|
            mapped_name = Packager::Solaris::SCRIPT_MAP[script_name.to_sym]
            script_file = "#{staging_dir}/#{mapped_name}"
            contents = File.read(script_file)
            expect(contents).to include("Contents of #{script_name}")
          end
        end
      end
    end

    describe "#write_prototype_file" do
      let(:prototype_file) { File.join(staging_dir, "Prototype") }

      before do
        allow(subject).to receive(:shellout!)
        File.open("#{staging_dir}/files", "w+") do |f|
          f.write <<~EOF
            /foo/bar/baz
            /a file with spaces
          EOF
        end
      end

      it "creates the prototype file" do
        subject.write_prototype_file
        contents = File.read(prototype_file)

        expect(contents).to include(
          <<-EOH.gsub(/^ {12}/, "")
            i pkginfo
            i postinstall
            i postremove
          EOH
        )
      end

      it "uses the correct commands" do
        expect(subject).to receive(:shellout!)
          .with("cd /opt && find project -print > #{File.join(staging_dir, "files")}")
        expect(subject).to receive(:shellout!)
          .with("cd /opt && pkgproto < #{File.join(staging_dir, "files.clean")} > #{File.join(staging_dir, "Prototype.files")}")
        expect(subject).to receive(:shellout!)
          .with("awk '{ $5 = \"root\"; $6 = \"root\"; print }' < #{File.join(staging_dir, "Prototype.files")} >> #{File.join(staging_dir, "Prototype")}")
        subject.write_prototype_file
      end

      it "strips out the file with spaces from files.clean" do
        subject.write_prototype_file
        contents = File.read(File.join(staging_dir, "files.clean"))
        expect(contents).not_to include("a file with spaces")
        expect(contents).to include("/foo/bar/baz")
      end
    end

    describe "#create_solaris_file" do
      it "uses the correct commands" do
        expect(subject).to receive(:shellout!)
          .with("pkgmk -o -r /opt -d #{staging_dir} -f #{File.join(staging_dir, "Prototype")}")
        expect(subject).to receive(:shellout!)
          .with("pkgchk -vd #{staging_dir} project")
        expect(subject).to receive(:shellout!)
          .with("pkgtrans #{staging_dir} #{File.join(package_dir, "project-1.2.3-1.i386.solaris")} project")

        subject.create_solaris_file
      end
    end

    describe "#write_pkginfo_file" do
      let(:pkginfo_file) { File.join(staging_dir, "pkginfo") }
      let(:hostname) { Socket.gethostname }
      let(:now) { Time.now }

      it "generates the file" do
        subject.write_pkginfo_file
        expect(pkginfo_file).to be_a_file
      end

      it "has the correct content" do
        allow(Time).to receive(:now).and_return(now)
        subject.write_pkginfo_file
        contents = File.read(pkginfo_file)

        expect(contents).to include("CLASSES=none")
        expect(contents).to include("TZ=PST")
        expect(contents).to include("PATH=/sbin:/usr/sbin:/usr/bin:/usr/sadm/install/bin")
        expect(contents).to include("BASEDIR=/opt")
        expect(contents).to include("PKG=project")
        expect(contents).to include("NAME=project")
        expect(contents).to include("ARCH=i386")
        expect(contents).to include("VERSION=1.2.3-1")
        expect(contents).to include("CATEGORY=application")
        expect(contents).to include("DESC=")
        expect(contents).to include("VENDOR=Chef Software")
        expect(contents).to include("EMAIL=Chef Software")
        expect(contents).to include("PSTAMP=#{hostname}#{now.utc.iso8601}")
      end
    end

    describe "#create_solaris_file" do
      before do
        allow(subject).to receive(:shellout!)
        allow(Dir).to receive(:chdir) { |_, &b| b.call }
      end

      it "uses the correct commands" do
        expect(subject).to receive(:shellout!)
          .with("pkgmk -o -r /opt -d #{staging_dir} -f #{File.join(staging_dir, "Prototype")}")
        expect(subject).to receive(:shellout!)
          .with("pkgchk -vd #{staging_dir} project")
        expect(subject).to receive(:shellout!)
          .with("pkgtrans #{staging_dir} #{File.join(package_dir, "project-1.2.3-1.i386.solaris")} project")

        subject.create_solaris_file
      end
    end

    describe "#safe_architecture" do
      context "the architecture is Intel-based" do
        let(:architecture) { "i86pc" }

        it "returns `i386`" do
          expect(subject.safe_architecture).to eq("i386")
        end
      end

      context "the architecture is SPARC-based" do
        let(:architecture) { "sun4v" }

        it "returns `sparc`" do
          expect(subject.safe_architecture).to eq("sparc")
        end
      end

      context "anything else" do
        let(:architecture) { "FOO" }

        it "returns the value from Ohai" do
          expect(subject.safe_architecture).to eq("FOO")
        end
      end
    end
  end
end