#!/usr/bin/env ruby

require File.dirname(__FILE__) + '/../../spec_helper'

require 'puppet/node/environment'
require 'puppet/util/execution'

describe Puppet::Node::Environment do
    after do
        Puppet::Node::Environment.clear
    end

    it "should include the Cacher module" do
        Puppet::Node::Environment.ancestors.should be_include(Puppet::Util::Cacher)
    end

    it "should use the filetimeout for the ttl for the modulepath" do
        Puppet::Node::Environment.attr_ttl(:modulepath).should == Integer(Puppet[:filetimeout])
    end

    it "should use the filetimeout for the ttl for the module list" do
        Puppet::Node::Environment.attr_ttl(:modules).should == Integer(Puppet[:filetimeout])
    end

    it "should use the default environment if no name is provided while initializing an environment" do
        Puppet.settings.expects(:value).with(:environment).returns("one")
        Puppet::Node::Environment.new().name.should == :one
    end

    it "should treat environment instances as singletons" do
        Puppet::Node::Environment.new("one").should equal(Puppet::Node::Environment.new("one"))
    end

    it "should treat an environment specified as names or strings as equivalent" do
        Puppet::Node::Environment.new(:one).should equal(Puppet::Node::Environment.new("one"))
    end

    it "should return its name when converted to a string" do
        Puppet::Node::Environment.new(:one).to_s.should == "one"
    end

    it "should consider its module path to be the environment-specific modulepath setting" do
        FileTest.stubs(:directory?).returns true
        env = Puppet::Node::Environment.new("testing")
        module_path = %w{/one /two}.join(File::PATH_SEPARATOR)
        env.expects(:[]).with(:modulepath).returns module_path

        env.modulepath.should == %w{/one /two}
    end

    it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do
        FileTest.stubs(:directory?).returns true
        Puppet::Util::Execution.withenv("PUPPETLIB" => %w{/l1 /l2}.join(File::PATH_SEPARATOR)) do
            env = Puppet::Node::Environment.new("testing")
            module_path = %w{/one /two}.join(File::PATH_SEPARATOR)
            env.expects(:[]).with(:modulepath).returns module_path

            env.modulepath.should == %w{/l1 /l2 /one /two}
        end
    end

    it "should not return non-directories in the module path" do
        env = Puppet::Node::Environment.new("testing")
        module_path = %w{/one /two}.join(File::PATH_SEPARATOR)
        env.expects(:[]).with(:modulepath).returns module_path

        FileTest.expects(:directory?).with("/one").returns true
        FileTest.expects(:directory?).with("/two").returns false

        env.modulepath.should == %w{/one}
    end

    it "should use the current working directory to fully-qualify unqualified paths" do
        FileTest.stubs(:directory?).returns true
        env = Puppet::Node::Environment.new("testing")
        module_path = %w{/one two}.join(File::PATH_SEPARATOR)
        env.expects(:[]).with(:modulepath).returns module_path

        two = File.join(Dir.getwd, "two")
        env.modulepath.should == ["/one", two]
    end

    describe "when modeling a specific environment" do
        it "should have a method for returning the environment name" do
            Puppet::Node::Environment.new("testing").name.should == :testing
        end

        it "should provide an array-like accessor method for returning any environment-specific setting" do
            env = Puppet::Node::Environment.new("testing")
            env.should respond_to(:[])
        end

        it "should ask the Puppet settings instance for the setting qualified with the environment name" do
            Puppet.settings.expects(:value).with("myvar", :testing).returns("myval")
            env = Puppet::Node::Environment.new("testing")
            env["myvar"].should == "myval"
        end

        it "should be able to return an individual module that exists in its module path" do
            env = Puppet::Node::Environment.new("testing")

            mod = mock 'module'
            Puppet::Module.expects(:new).with("one", env).returns mod
            mod.expects(:exist?).returns true

            env.module("one").should equal(mod)
        end

        it "should return nil if asked for a module that does not exist in its path" do
            env = Puppet::Node::Environment.new("testing")

            mod = mock 'module'
            Puppet::Module.expects(:new).with("one", env).returns mod
            mod.expects(:exist?).returns false

            env.module("one").should be_nil
        end

        it "should be able to return its modules" do
            Puppet::Node::Environment.new("testing").should respond_to(:modules)
        end

        describe ".modules" do
            it "should return a module named for every directory in each module path" do
                env = Puppet::Node::Environment.new("testing")
                env.expects(:modulepath).returns %w{/a /b}
                Dir.expects(:entries).with("/a").returns %w{foo bar}
                Dir.expects(:entries).with("/b").returns %w{bee baz}

                env.modules.collect{|mod| mod.name}.sort.should == %w{foo bar bee baz}.sort
            end

            it "should remove duplicates" do
                env = Puppet::Node::Environment.new("testing")
                env.expects(:modulepath).returns %w{/a /b}
                Dir.expects(:entries).with("/a").returns %w{foo}
                Dir.expects(:entries).with("/b").returns %w{foo}

                env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
            end

            it "should ignore invalid modules" do
                env = Puppet::Node::Environment.new("testing")
                env.expects(:modulepath).returns %w{/a}
                Dir.expects(:entries).with("/a").returns %w{foo bar}

                Puppet::Module.expects(:new).with { |name, env| name == "foo" }.returns mock("foomod", :name => "foo")
                Puppet::Module.expects(:new).with { |name, env| name == "bar" }.raises Puppet::Module::InvalidName

                env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
            end

            it "should create modules with the correct environment" do
                env = Puppet::Node::Environment.new("testing")
                env.expects(:modulepath).returns %w{/a}
                Dir.expects(:entries).with("/a").returns %w{foo}

                env.modules.should be_all{|mod| mod.environment == "testing" }
            end

            it "should cache the module list" do
                env = Puppet::Node::Environment.new("testing")
                env.expects(:modulepath).once.returns %w{/a}
                Dir.expects(:entries).once.with("/a").returns %w{foo}

                env.modules
                env.modules
            end
        end
    end
end