summaryrefslogtreecommitdiffstats
path: root/test/ral/providers/sshkey/parsed.rb
blob: d7d083db00f6eea1838dbbac2b3d73844965a277 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#!/usr/bin/env ruby

require File.dirname(__FILE__) + '/../../../lib/puppettest'

require 'puppettest'
require 'puppettest/fileparsing'

class TestParsedSSHKey < Test::Unit::TestCase
	include PuppetTest
	include PuppetTest::FileParsing

    def setup
        super
        @provider = Puppet::Type.type(:sshkey).provider(:parsed)

        @oldfiletype = @provider.filetype
    end

    def teardown
        Puppet::Util::FileType.filetype(:ram).clear
        @provider.filetype = @oldfiletype
        @provider.clear
        super
    end
    
    def mkkey(name = "host.domain.com")
        if defined? @pcount
            @pcount += 1
        else
            @pcount = 1
        end
        args = {
            :name => name || "/fspuppet%s" % @pcount,
            :key => "thisismykey%s" % @pcount,
            :alias => ["host1.domain.com","192.168.0.1"],
            :type => "dss",
            :ensure => :present
        }

        fakeresource = fakeresource(:sshkey, args[:name])

        key = @provider.new(fakeresource)
        args.each do |p,v|
            key.send(p.to_s + "=", v)
        end

        return key
    end

    def test_keysparse
        fakedata("data/types/sshkey").each { |file|
            fakedataparse(file)
        }
    end
    
    def test_simplekey
        @provider.filetype = :ram
        file = @provider.default_target
        
        key = nil
        assert_nothing_raised do
            key = mkkey
        end
        
        assert(key, "did not create key")
        
        assert_nothing_raised do
            key.flush
        end
        
        assert(key.alias, "No alias set for key")
        
        hash = key.property_hash.dup
        text = @provider.target_object(file).read
        names = [key.name, key.alias].flatten.join(",")
        
        assert_equal("#{names} #{key.type} #{key.key}\n", text)
        
        assert_nothing_raised do
            @provider.prefetch
        end
        
        hash.each do |p, v|
            next unless key.respond_to?(p)
            assert_equal(v, key.send(p), "%s did not match" % p)
        end
        
        assert(key.name !~ /,/, "Aliases were not split out during parsing")
    end

    def test_hooks
        result = nil
        assert_nothing_raised("Could not call post hook") do
            result = @provider.parse_line("one,two type key")
        end
        assert_equal("one", result[:name], "Did not call post hook")
        assert_equal(%w{two}, result[:alias], "Did not call post hook")

        assert_equal("one,two type key",
            @provider.to_line(:record_type => :parsed,
            :name => "one",
            :alias => %w{two},
            :type => "type",
            :key => "key"),
            "Did not use pre-hook when generating line"
        )
    end
end