puppet 0.22.4 → 0.23.0

data/test/ral/types/yumrepo.rb

@@ -23,10 +23,10 @@ class TestYumRepo < Test::Unit::TestCase
     def test_modify
         copy_datafiles
         devel = make_repo("development", { :descr => "New description" })
-        devel.retrieve
+        current_values = devel.retrieve
         assert_equal("development", devel[:name])
         assert_equal('Fedora Core $releasever - Development Tree', 
-                     devel.property(:descr).is)
+                     current_values[devel.property(:descr)])
         assert_equal('New description', 
                      devel.property(:descr).should)
         assert_apply(devel)

data/test/ral/types/zone.rb

@@ -5,42 +5,14 @@ $:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 require 'puppettest'
 require 'puppet/type/zone'
 
-class TestZone < Test::Unit::TestCase
-	include PuppetTest
-
-    def test_nothing
-    end
-
-    # Zones can only be tested on solaris.
-    if Facter["operatingsystem"].value == "Solaris"
+class TestZone < PuppetTest::TestCase
+    confine "Zones are only functional on Solaris" => (Facter["operatingsystem"].value == "Solaris")
 
     def setup
         super
         @@zones = []
     end
 
-    def teardown
-        current = %x{zoneadm list -cp}.split("\n").inject({}) { |h, line|
-            ary = line.split(":")
-            h[ary[1]] = ary[2]
-            h
-        }
-
-        Puppet::Type.type(:zone).clear
-
-        # Get rid of any lingering zones
-        @@zones.each do |zone|
-            next unless current.include? zone
-
-            obj = Puppet::Type.type(:zone).create(:name => zone)
-            obj[:ensure] = :absent
-            assert_apply(obj)
-        end
-
-        # We can't delete the temp files until the zones are stopped and removed.
-        super
-    end
-
     def mkzone(name)
         zone = nil
 
@@ -61,10 +33,10 @@ class TestZone < Test::Unit::TestCase
         return zone
     end
 
-    def test_list
+    def test_instances
         list = nil
         assert_nothing_raised {
-            list = Puppet::Type.type(:zone).list
+            list = Puppet::Type.type(:zone).instances
         }
 
         assert(! list.empty?, "Got no zones back")
@@ -72,14 +44,14 @@ class TestZone < Test::Unit::TestCase
         assert(list.find { |z| z[:name] == "global" }, "Could not find global zone")
     end
 
-    def test_valueslice
+    def test_state_sequence
         zone = mkzone("slicetest")
 
         property = zone.property(:ensure)
 
         slice = nil
         assert_nothing_raised {
-            slice = property.class.valueslice(:absent, :installed).collect do |o|
+            slice = property.class.state_sequence(:absent, :installed).collect do |o|
                 o[:name]
             end
         }
@@ -88,7 +60,7 @@ class TestZone < Test::Unit::TestCase
         assert_equal([:configured, :installed], slice)
 
         assert_nothing_raised {
-            slice = property.class.valueslice(:running, :installed).collect do |o|
+            slice = property.class.state_sequence(:running, :installed).collect do |o|
                 o[:name]
             end
         }
@@ -106,15 +78,15 @@ class TestZone < Test::Unit::TestCase
 
         assert(property, "Did not get ensure property")
 
+        values = nil
         assert_nothing_raised {
-            zone.retrieve
+            values = zone.retrieve
         }
 
-        assert(! property.insync?, "Property is somehow in sync")
+        assert(! property.insync?(values[property]), "Property is somehow in sync")
 
         assert(property.up?, "Property incorrectly thinks it is not moving up")
 
-        zone.is = [:ensure, :configured]
         zone[:ensure] = :installed
         assert(property.up?, "Property incorrectly thinks it is not moving up")
         zone[:ensure] = :absent
@@ -128,7 +100,7 @@ class TestZone < Test::Unit::TestCase
 
         property = zone.property(:ensure)
         assert_nothing_raised {
-            property.class.valueslice(:absent, :running).each do |st|
+            property.class.state_sequence(:absent, :running).each do |st|
                 [:up, :down].each do |m|
                     if st[m]
                         methods << st[m]
@@ -161,7 +133,7 @@ class TestZone < Test::Unit::TestCase
         assert_equal("add inherit-pkg-dir\nset dir=/usr\nend", property.configtext,
             "Got incorrect config text")
 
-        property.is = "/usr"
+        zone.provider.inherit = "/usr"
 
         assert_equal("", property.configtext,
             "Got incorrect config text")
@@ -180,7 +152,7 @@ end"
         assert_equal(text, property.configtext,
             "Got incorrect config text")
 
-        property.is = %w{/usr /sbin /lib}
+        zone.provider.inherit = %w{/usr /sbin /lib}
         property.should = %w{/usr /sbin}
 
         text = "remove inherit-pkg-dir dir=/lib"
@@ -188,20 +160,42 @@ end"
         assert_equal(text, property.configtext,
             "Got incorrect config text")
     end
+end
+
+class TestZoneAsRoot < TestZone
+    confine "Not running Zone creation tests" => Puppet.features.root?
+    confine "Zones are only functional on Solaris" => (Facter["operatingsystem"].value == "Solaris")
+
+    def teardown
+        current = %x{zoneadm list -cp}.split("\n").inject({}) { |h, line|
+            ary = line.split(":")
+            h[ary[1]] = ary[2]
+            h
+        }
+
+        Puppet::Type.type(:zone).clear
+
+        # Get rid of any lingering zones
+        @@zones.each do |zone|
+            next unless current.include? zone
+
+            obj = Puppet::Type.type(:zone).create(:name => zone)
+            obj[:ensure] = :absent
+            assert_apply(obj)
+        end
 
-    if Puppet::Util::SUIDManager.uid == 0
+        # We can't delete the temp files until the zones are stopped and removed.
+        super
+    end
     # Make sure our ensure process actually works.
     def test_ensure_sync
         zone = mkzone("ensuretesting")
 
         zone[:ensure] = :configured
 
-        zone.retrieve
         assert_apply(zone)
 
-        zone.retrieve
-
-        assert(zone.insync?, "Zone is not insync")
+        assert(zone.insync?(zone.retrieve), "Zone is not insync")
     end
 
     def test_getconfig
@@ -242,25 +236,27 @@ end
 
         assert_equal(0, $?, "Did not successfully create zone")
 
-        #@@zones << "configtesting"
-
         hash = nil
         assert_nothing_raised {
             hash = zone.provider.send(:getconfig)
         }
 
-        # Now set the configuration
-        assert_nothing_raised { zone.send(:config2status, hash) }
+        zone[:check] = [:inherit, :autoboot]
+
+        values = nil
+        assert_nothing_raised("Could not retrieve zone values") do
+            values = zone.retrieve.inject({}) { |result, newvals| result[newvals[0].name] = newvals[1]; result }
+        end
 
         # And make sure it gets set correctly.
         assert_equal(%w{/sbin /usr /opt/csw /lib /platform}.sort,
-            zone.is(:inherit).sort, "Inherited dirs did not get collected correctly."
+            values[:inherit].sort, "Inherited dirs did not get collected correctly."
         )
 
-        assert_equal(["#{interface}:#{ip}"], zone.is(:ip),
+        assert_equal(["#{interface}:#{ip}"], values[:ip],
             "IP addresses did not get collected correctly.")
 
-        assert_equal(:true, zone.is(:autoboot),
+        assert_equal(:true, values[:autoboot],
             "Autoboot did not get collected correctly.")
     end
 
@@ -274,12 +270,9 @@ end
 
         zone[:ensure] = :configured
 
-        zone.retrieve
         assert_apply(zone)
 
-        zone.retrieve
-
-        assert(zone.insync?, "Zone is not insync")
+        assert(zone.insync?(zone.retrieve), "Zone is not insync")
 
         # Now add a new directory to inherit
         assert_nothing_raised {
@@ -287,9 +280,7 @@ end
         }
         assert_apply(zone)
 
-        zone.retrieve
-
-        assert(zone.insync?, "Zone is not insync")
+        assert(zone.insync?(zone.retrieve), "Zone is not insync")
 
         assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /dir: \/sbin/,
             "sbin was not added")
@@ -300,9 +291,7 @@ end
         }
         assert_apply(zone)
 
-        zone.retrieve
-
-        assert(zone.insync?, "Zone is not insync")
+        assert(zone.insync?(zone.retrieve), "Zone is not insync")
 
         assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} !~ /dir: \/sbin/,
             "sbin was not removed")
@@ -311,18 +300,15 @@ end
         # that the interface exists.
         zone[:ip] = "hme0:192.168.0.1"
 
-        zone.retrieve
-        assert(! zone.insync?, "Zone is marked as in sync")
+        assert(! zone.insync?(zone.retrieve), "Zone is marked as in sync")
 
         assert_apply(zone)
-        zone.retrieve
-        assert(zone.insync?, "Zone is not in sync")
+        assert(zone.insync?(zone.retrieve), "Zone is not in sync")
         assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /192.168.0.1/,
             "ip was not added")
         zone[:ip] = ["hme1:192.168.0.2", "hme0:192.168.0.1"]
         assert_apply(zone)
-        zone.retrieve
-        assert(zone.insync?, "Zone is not in sync")
+        assert(zone.insync?(zone.retrieve), "Zone is not in sync")
         assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /192.168.0.2/,
             "ip was not added")
         zone[:ip] = ["hme1:192.168.0.2"]
@@ -348,22 +334,20 @@ end
 
         zone[:ensure] = :configured
 
-        assert(! zone.insync?, "Zone is incorrectly in sync")
+        assert(! zone.insync?(zone.retrieve), "Zone is incorrectly in sync")
 
         assert_apply(zone)
 
-        assert_nothing_raised {
-            zone.retrieve
-        }
-        assert(zone.insync?, "Zone is incorrectly out of sync")
+        assert(zone.insync?(zone.retrieve), "Zone is incorrectly out of sync")
 
         zone[:ensure] = :absent
 
         assert_apply(zone)
 
-        zone.retrieve
+        currentvalues = zone.retrieve
 
-        assert_equal(:absent, zone.is(:ensure), "Zone is not absent")
+        assert_equal(:absent, currentvalues[zone.property(:ensure)], 
+                     "Zone is not absent")
     end
 
     # Just go through each method linearly and make sure it works.
@@ -384,16 +368,18 @@ end
             [:unconfigure, :absent]
         ].each do |method, property|
             Puppet.info "Testing %s" % method
+            current_values = nil
             assert_nothing_raised {
-                zone.retrieve
+                current_values = zone.retrieve
             }
             assert_nothing_raised {
                 zone.provider.send(method)
             }
+            current_values = nil
             assert_nothing_raised {
-                zone.retrieve
+                current_values = zone.retrieve
             }
-            assert_equal(property, zone.is(:ensure),
+            assert_equal(property, current_values[zone.property(:ensure)],
                 "Method %s did not correctly set property %s" %
                     [method, property])
         end
@@ -416,22 +402,20 @@ end
             assert_nothing_raised {
                 zone[:ensure] = value
             }
-            assert(! zone.insync?, "Zone is incorrectly in sync")
+            assert(! zone.insync?(zone.retrieve), "Zone is incorrectly in sync")
 
             assert_apply(zone)
 
             assert_nothing_raised {
-                zone.retrieve
+                assert(zone.insync?(zone.retrieve), "Zone is incorrectly out of sync")
             }
-            assert(zone.insync?, "Zone is incorrectly out of sync")
         end
 
-        zone.retrieve
+        currentvalues = zone.retrieve
 
-        assert_equal(:absent, zone.is(:ensure), "Zone is not absent")
-    end
-    end
+        assert_equal(:absent, currentvalues[zone.property(:ensure)], 
+                     "Zone is not absent")
     end
 end
 
-# $Id: zone.rb 2178 2007-02-07 23:56:59Z luke $
+# $Id: zone.rb 2576 2007-06-14 03:39:00Z luke $

data/test/util/autoload.rb

@@ -74,7 +74,7 @@ TestAutoload.newthing(:#{name.to_s})
         # Now try to actually load it.
         assert_nothing_raised {
             assert_equal(true, loader.load(:mything),
-                        "got incorrect return on failed load")
+                        "got incorrect return on load")
         }
 
         assert(loader.loaded?(:mything), "Not considered loaded")
@@ -103,28 +103,13 @@ TestAutoload.newthing(:#{name.to_s})
 
     # Make sure that autoload dynamically modifies $: with the libdir as
     # appropriate.
-    def test_autoload_uses_libdir
+    def test_searchpath
         dir = Puppet[:libdir]
-        unless FileTest.directory?(dir)
-            Dir.mkdir(dir)
-        end
-
-        loader = File.join(dir, "test")
-        Dir.mkdir(loader)
-        name = "funtest"
-        file = File.join(loader, "funtest.rb")
-        File.open(file, "w") do |f|
-            f.puts "$loaded = true"
-        end
 
-        auto = Puppet::Util::Autoload.new(self, "test")
+        loader = Puppet::Util::Autoload.new(self, "testing")
 
-        # Now make sure autoloading modifies $: as necessary
-        assert(! $:.include?(dir), "search path already includes libdir")
-
-        assert_nothing_raised do
-            assert(auto.load("funtest"), "did not successfully load funtest")
-        end
-        assert($:.include?(dir), "libdir did not get added to search path")
+        assert(loader.send(:searchpath).include?(dir), "searchpath does not include the libdir")
     end
 end
+
+# $Id: autoload.rb 2518 2007-05-16 00:00:47Z luke $

data/test/util/config.rb

@@ -2,6 +2,7 @@
 
 $:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
+require 'mocha'
 require 'puppet'
 require 'puppet/util/config'
 require 'puppettest'
@@ -196,7 +197,65 @@ class TestConfig < Test::Unit::TestCase
         assert_equal("not default", @config[:yayness])
     end
 
-    def test_parse
+    def test_parse_file
+        text = %{
+one = this is a test
+two = another test
+owner = root
+group = root
+yay = /a/path
+
+[main]
+    four = five
+    six = seven
+
+[section1]
+    attr = value
+    owner = puppet
+    group = puppet
+    attrdir = /some/dir
+    attr3 = $attrdir/other
+        }
+
+        file = tempfile()
+        File.open(file, "w") { |f| f.puts text }
+
+        @config.expects(:settimer)
+        
+        result = nil
+        assert_nothing_raised {
+            result = @config.send(:parse_file, file)
+        }
+
+        main = result[:main]
+        assert(main, "Did not get section for main")
+        {
+            :one => "this is a test",
+            :two => "another test",
+            :owner => "root",
+            :group => "root",
+            :yay => "/a/path",
+            :four => "five",
+            :six => "seven"
+        }.each do |param, value|
+            assert_equal(value, main[param], "Param %s was not set correctly in main" % param)
+        end
+
+        section1 = result[:section1]
+        assert(section1, "Did not get section1")
+
+        {
+            :attr => "value",
+            :owner => "puppet",
+            :group => "puppet",
+            :attrdir => "/some/dir",
+            :attr3 => "$attrdir/other"
+        }.each do |param, value|
+            assert_equal(value, section1[param], "Param %s was not set correctly in section1" % param)
+        end
+    end
+
+    def test_old_parse
         text = %{
 one = this is a test
 two = another test
@@ -233,7 +292,7 @@ yay = /a/path
         }
         
         assert_nothing_raised {
-            @config.parse(file)
+            @config.old_parse(file)
         }
 
         assert_equal("value", @config[:attr])
@@ -267,6 +326,137 @@ yay = /a/path
         check_to_transportable(@config)
     end
 
+    def test_parse
+        result = {
+            :main => {:main => "main", :bad => "invalid"},
+            :puppet => {:other => "puppet"},
+            :puppetd => {:other => "puppetd"}
+        }
+        # Set our defaults, so they're valid. Don't define 'bad', since we want to test for failures.
+        @config.setdefaults(:main,
+            :main => ["whatever", "a"],
+            :other => ["a", "b"],
+            :name => ["puppet", "b"] # our default name
+        )
+        @config.expects(:parse_file).returns(result).times(2)
+
+        # First do it with our name being 'puppet'
+        assert_nothing_raised("Could not handle parse results") do
+            @config.parse(tempfile)
+        end
+
+        assert_logged(:warning, /unknown configuration parameter bad/, "Did not log invalid config param")
+
+        assert_equal("main", @config[:main], "Did not get main value")
+        assert_equal("puppet", @config[:other], "Did not get name value")
+
+        # Now switch names and make sure the parsing switches, too.
+        @config.clear
+        @config[:name] = :puppetd
+        assert_nothing_raised("Could not handle parse results") do
+            @config.parse(tempfile)
+        end
+        assert_logged(:warning, /unknown configuration parameter bad/, "Did not log invalid config param")
+
+        assert_equal("main", @config[:main], "Did not get main value")
+        assert_equal("puppetd", @config[:other], "Did not get name value")
+    end
+
+    # Make sure we can extract file options correctly.
+    def test_parsing_file_options
+        @config.setdefaults(:whev,
+            :file => {
+                :desc => "whev",
+                :default => "/default",
+                :owner => "me",
+                :group => "me",
+                :mode => "755"
+            }
+        )
+
+        file = tempfile
+
+        {
+            :pass => {
+                " {owner = you}" => {:owner => "you"},
+                " {owner = you, group = you}" => {:owner => "you", :group => "you"},
+                " {owner = you, group = you, mode = 755}" => {:owner => "you", :group => "you", :mode => "755"},
+                " { owner = you, group = you } " => {:owner => "you", :group => "you"},
+                "{owner=you,group=you} " => {:owner => "you", :group => "you"},
+                "{owner=you,} " => {:owner => "you"}
+            },
+            :fail => [
+                %{{owner = you group = you}},
+                %{{owner => you, group => you}},
+                %{{user => you}},
+                %{{random => you}},
+                %{{mode => you}}, # make sure modes are numbers
+                %{{owner => you}}
+            ]
+        }.each do |type, list|
+            list.each do |value|
+                if type == :pass
+                    value, should = value[0], value[1]
+                end
+                # Write our file out
+                File.open(file, "w") do |f|
+                    f.puts %{[main]\nfile = /other%s} % value
+                end
+
+                if type == :fail
+                    assert_raise(Puppet::Error, "Did not fail on %s" % value.inspect) do
+                        @config.send(:parse_file, file)
+                    end
+                else
+                    result = nil
+                    assert_nothing_raised("Failed to parse %s" % value.inspect) do
+                        result = @config.send(:parse_file, file)
+                    end
+                    assert_equal(should, result[:main][:_meta][:file], "Got incorrect return for %s" % value.inspect)
+                end
+            end
+        end
+    end
+
+    # Make sure file options returned from parse_file are handled correctly.
+    def test_parsed_file_options
+        @config.setdefaults(:whev,
+            :file => {
+                :desc => "whev",
+                :default => "/default",
+                :owner => "me",
+                :group => "me",
+                :mode => "755"
+            }
+        )
+
+        result = {
+            :main => {
+                :file => "/other",
+                :_meta => {
+                    :file => {
+                        :owner => "you",
+                        :group => "you",
+                        :mode => "644"
+                    }
+                }
+            }
+        }
+
+        @config.expects(:parse_file).returns(result)
+
+        assert_nothing_raised("Could not handle file options") do
+            @config.parse("/whatever")
+        end
+
+        # Get the actual object, so we can verify metadata
+        file = @config.element(:file)
+
+        assert_equal("you", file.owner, "Did not pass on user")
+        assert_equal("you", file.group, "Did not pass on group")
+        assert_equal("644", file.mode, "Did not pass on mode")
+    end
+
     def test_arghandling
         c = mkconfig
 
@@ -517,7 +707,7 @@ yay = /a/path
         group = "yayness"
 
         File.open(cfile, "w") do |f|
-            f.puts "[#{Puppet[:name]}]
+            f.puts "[main]
             group = #{group}
             "
         end
@@ -624,7 +814,7 @@ yay = /a/path
 
         File.open(file, "w") do |f|
             f.puts %{
-[mysection]
+[main]
 booltest = true
 inttest = 27
 }
@@ -726,7 +916,7 @@ inttest = 27
         file = tempfile()
         # Set one parameter in the file
         File.open(file, "w") { |f|
-            f.puts %{[mysection]\nfilechange = filevalue}
+            f.puts %{[main]\nfilechange = filevalue}
         }
         assert_nothing_raised {
             config.parse(file)
@@ -744,7 +934,7 @@ inttest = 27
 
         # Now rewrite the file
         File.open(file, "w") { |f|
-            f.puts %{[mysection]\nfilechange = newvalue}
+            f.puts %{[main]\nfilechange = newvalue}
         }
 
         cfile = config.file
@@ -766,7 +956,7 @@ inttest = 27
         file = tempfile()
         # Set one parameter in the file
         File.open(file, "w") { |f|
-            f.puts %{[mysection]\n
+            f.puts %{[main]\n
     singleq = 'one'
     doubleq = "one"
     none = one
@@ -793,7 +983,7 @@ inttest = 27
         file = tempfile()
         # Set one parameter in the file
         File.open(file, "w") { |f|
-            f.puts %{[mysection]\n
+            f.puts %{[main]\n
     paramdir = #{origpath}
 }
         }
@@ -813,7 +1003,7 @@ inttest = 27
         newpath = tempfile()
 
         File.open(file, "w") { |f|
-            f.puts %{[mysection]\n
+            f.puts %{[main]\n
     paramdir = #{newpath}
 }
         }
@@ -941,7 +1131,7 @@ inttest = 27
         config.setdefaults(:mysection, :one => ["yay", "yay"])
         file = tempfile()
         File.open(file, "w") { |f|
-            f.puts %{[mysection]\n
+            f.puts %{[main]\n
                 one = one
                 two = yay
             }
@@ -977,96 +1167,6 @@ inttest = 27
         assert_equal("oneval/twoval/oneval/twoval", @config[:three],
             "Did not interpolate curlied variables")
     end
-
-    # #489
-    def test_modes
-        Puppet[:name] = "puppet"
-        config = tempfile()
-
-        check = Proc.new do |string, int|
-            trans = @config.section_to_transportable(:puppet)
-            ssldir = trans.find { |o| o.type == "file"  }
-            assert(ssldir, "could not find trans object")
-
-            if ssldir[:mode].is_a?(Fixnum)
-                assert_equal(int, ssldir[:mode], "mode not set correctly")
-            else
-                assert_equal(string, ssldir[:mode], "mode not set correctly")
-            end
-
-            obj = nil
-            assert_nothing_raised { obj = ssldir.to_type }
-
-            assert(obj, "did not create object")
-            assert_equal(int, obj.should(:mode),
-                "did not pass mode correctly to file")
-
-            obj.class.clear
-        end
-
-        file = tempfile
-        @config.setdefaults(:puppet, :mode => ["644", "yay"])
-        @config.setdefaults(:puppet, :ssldir => {
-            :mode => 0644,
-            :desc => "yay",
-            :default => "/some/file"})
-
-        # Convert it first using the number
-        check.call("644", 0644)
-
-        File.open(config, "w") { |f| f.puts "[puppet]
-        mode = 750
-        ssldir = #{file}
-        "}
-
-        @config.parse(config)
-
-        assert_equal("750", @config[:mode],
-            "Did not parse mode correctly")
-
-        check.call("750", 0750)
-    end
-
-    def test_only_set_metas_when_valid
-        file = tempfile
-        config = tempfile
-        @config.setdefaults(Puppet[:name], :ssldir => {
-            :mode => 0644,
-            :group => "yayness",
-            :desc => "yay",
-            :default => "/some/file"})
-
-        File.open(config, "w") { |f| f.puts "[#{Puppet[:name]}]
-        mode = 755
-        group = foo
-        ssldir = #{file}
-        "}
-
-        assert_nothing_raised do
-            @config.parse(config)
-        end
-
-        assert_raise(ArgumentError) do
-            @config[:mode]
-        end
-        assert_raise(ArgumentError) do
-            @config[:group]
-        end
-
-        # Now make them valid params
-        @config.setdefaults(Puppet[:name], :group => ["blah", "yay"])
-        @config.setdefaults(Puppet[:name], :mode => ["750", "yay"])
-
-        assert_nothing_raised do
-            @config.parse(config)
-        end
-
-        assert_equal("foo", @config[:group],
-            "Did not store group when it is a valid config")
-        assert_equal("755", @config[:mode],
-            "Did not store mode when it is a valid config")
-
-    end
 end
 
-# $Id: config.rb 2273 2007-03-08 17:35:18Z luke $
+# $Id: config.rb 2464 2007-05-06 05:42:53Z luke $