ztk 3.0.4 → 3.1.0

data/spec/ztk/config_spec.rb

@@ -22,19 +22,23 @@ require "spec_helper"
 
 describe ZTK::Config do
 
-  subject { class C; extend(ZTK::Config); end; C }
+  subject do
+    class C
+      extend(ZTK::Config)
+    end
+  end
 
   describe "class" do
 
     it "should be a kind of ZTK::Config" do
-      subject.should be_a_kind_of ZTK::Config
+      expect(subject).to be_a_kind_of ZTK::Config
     end
 
     describe "default config" do
 
       it "should have an OpenStruct object for holding the configuration" do
-        subject.configuration.should be_an_instance_of OpenStruct
-        subject.keys.length.should == 0
+        expect(subject.configuration).to be_an_instance_of OpenStruct
+        expect(subject.keys.length).to be == 0
       end
 
     end
@@ -45,20 +49,23 @@ describe ZTK::Config do
 
     it "should allow setting of arbratary configuration keys" do
       subject.thing = "something"
-      subject.thing.should == "something"
-      subject[:thing].should == "something"
+
+      expect(subject.thing).to be == "something"
+      expect(subject[:thing]).to be == "something"
     end
 
     it "should allow hash bracket style access to configuration keys" do
       subject[:thing] = "nothing"
-      subject[:thing].should == "nothing"
+
+      expect(subject[:thing]).to be == "nothing"
     end
 
     it "should allow loading of configurations from disk" do
       config_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "test-config.rb"))
       subject.from_file(config_file)
-      subject.message.should == "Hello World"
-      subject.thing.should == 2
+
+      expect(subject.message).to be == "Hello World"
+      expect(subject.thing).to be == 2
     end
 
   end

data/spec/ztk/locator_spec.rb

@@ -27,7 +27,7 @@ describe ZTK::Locator do
   describe "class" do
 
     it "should be ZTK::Locator" do
-      subject.should be ZTK::Locator
+      expect(subject).to be ZTK::Locator
     end
 
     describe "methods" do
@@ -35,11 +35,11 @@ describe ZTK::Locator do
       describe "#find" do
 
         it "should find home" do
-          subject.find("home").should == "/home"
+          expect(subject.find("home")).to be == "/home"
         end
 
         it "should not find funkytown_123_abc" do
-          lambda { subject.find("funkytown_123_abc") }.should raise_error ZTK::LocatorError
+          expect{ subject.find("funkytown_123_abc") }.to raise_error ZTK::LocatorError
         end
 
       end

data/spec/ztk/logger_spec.rb

@@ -20,30 +20,36 @@
 
 require "spec_helper"
 
+LOG_LEVEL_STEPS = [:debug, :info, :warn, :error, :fatal]
+
 describe ZTK::Logger do
 
-  before(:all) do
-    ENV["LOG_LEVEL"] = "DEBUG"
-    @messages = {
+  let(:messages) do
+    {
       :debug => "This is a test debug message",
       :info => "This is a test info message",
       :warn => "This is a test warn message",
       :error => "This is a test error message",
       :fatal => "This is a test fatal message"
     }
-    @logfile = File.join(ZTK::Locator.root, "tmp", "logger.log")
   end
 
+  let(:logfile) { File.join(File.dirname(Tempfile.new('logger')), "logger-#{Time.now.to_i}") }
+
+  subject { ZTK::Logger.new(logfile) }
+
   before(:each) do
-    File.exists?(@logfile) && File.delete(@logfile)
+    ENV["LOG_LEVEL"] = "DEBUG"
   end
 
-  subject { ZTK::Logger.new(@logfile) }
+  after(:each) do
+    File.exists?(logfile) && File.delete(logfile)
+  end
 
   describe "class" do
 
     it "should be an instance of ZTK::Logger" do
-      subject.should be_an_instance_of ZTK::Logger
+      expect(subject).to be_an_instance_of ZTK::Logger
     end
 
   end
@@ -51,28 +57,28 @@ describe ZTK::Logger do
   describe "general logging functionality" do
 
     it "should accept debug log messages" do
-      subject.debug { @messages[:debug] }
-      IO.read(@logfile).match(@messages[:debug]).should_not be nil
+      subject.debug { messages[:debug] }
+      expect(IO.read(logfile)).to match(messages[:debug])
     end
 
     it "should accept info log messages" do
-      subject.info { @messages[:info] }
-      IO.read(@logfile).match(@messages[:info]).should_not be nil
+      subject.info { messages[:info] }
+      expect(IO.read(logfile)).to match(messages[:info])
     end
 
     it "should accept warn log messages" do
-      subject.warn { @messages[:warn] }
-      IO.read(@logfile).match(@messages[:warn]).should_not be nil
+      subject.warn { messages[:warn] }
+      expect(IO.read(logfile)).to match(messages[:warn])
     end
 
     it "should accept error log messages" do
-      subject.error { @messages[:error] }
-      IO.read(@logfile).match(@messages[:error]).should_not be nil
+      subject.error { messages[:error] }
+      expect(IO.read(logfile)).to match(messages[:error])
     end
 
     it "should accept fatal log messages" do
-      subject.fatal { @messages[:fatal] }
-      IO.read(@logfile).match(@messages[:fatal]).should_not be nil
+      subject.fatal { messages[:fatal] }
+      expect(IO.read(logfile)).to match(messages[:fatal])
     end
 
   end
@@ -82,7 +88,7 @@ describe ZTK::Logger do
     it "should allow writing directly to the log device" do
       data = "Hello World"
       subject << data
-      IO.read(@logfile).match(data).should_not be nil
+      expect(IO.read(logfile)).to match(data)
     end
 
     it "should allow us to echo log statements to STDOUT" do
@@ -94,7 +100,7 @@ describe ZTK::Logger do
       subject.debug { data }
 
       stdout.rewind
-      stdout.read.match(data).should_not be nil
+      expect(stdout.read).to match(data)
     end
 
   end
@@ -102,55 +108,54 @@ describe ZTK::Logger do
   describe "log message" do
 
     before(:each) do
-      subject.debug { @messages[:debug] }
+      subject.debug { messages[:debug] }
     end
 
     it "should contain the date (YYYY-MM-DD)" do
-      IO.read(@logfile).match(Time.now.utc.strftime("%Y-%m-%d")).should_not be nil
+      expect(IO.read(logfile)).to match(Time.now.utc.strftime("%Y-%m-%d"))
     end
 
     it "should contain the time (HH:MM)" do
-      IO.read(@logfile).match(Time.now.utc.strftime("%H:%M")).should_not be nil
+      expect(IO.read(logfile)).to match(Time.now.utc.strftime("%H:%M"))
     end
 
     it "should contain the current process ID" do
-      IO.read(@logfile).match(Process.pid.to_s).should_not be nil
+      expect(IO.read(logfile)).to match(Process.pid.to_s)
     end
 
     it "should contain the current log level" do
-      IO.read(@logfile).match("DEBUG").should_not be nil
+      expect(IO.read(logfile)).to match("DEBUG")
     end
 
     it "should contain the basename of the file containing the method call" do
-      IO.read(@logfile).match(File.basename(__FILE__)).should_not be nil
+      expect(IO.read(logfile)).to match(File.basename(__FILE__))
     end
 
     it "should contain the log message itself" do
-      IO.read(@logfile).match(@messages[:debug]).should_not be nil
+      expect(IO.read(logfile)).to match(messages[:debug])
     end
 
   end
 
   describe "log level" do
 
-    LOG_LEVEL_STEPS = [:debug, :info, :warn, :error, :fatal]
-
     LOG_LEVEL_STEPS.each do |current_log_level_step|
 
       it "should allow setting log level to #{current_log_level_step.to_s.upcase} via ENV[\"#{current_log_level_step.to_s.upcase}\"]" do
 
         ENV["LOG_LEVEL"] = current_log_level_step.to_s.upcase
-        File.exists?(@logfile) && File.delete(@logfile)
-        subject = ZTK::Logger.new(@logfile)
 
         LOG_LEVEL_STEPS.each do |log_level_step|
-          subject.send(log_level_step) { @messages[log_level_step] }
+          subject.send(log_level_step) { messages[log_level_step] }
+
+          logdata = IO.read(logfile)
+
           if LOG_LEVEL_STEPS.index(log_level_step) >= LOG_LEVEL_STEPS.index(current_log_level_step)
-            IO.read(@logfile).match(@messages[log_level_step]).should_not be nil
-            IO.read(@logfile).match(log_level_step.to_s.upcase).should_not be nil
+            expect(logdata).to match(messages[log_level_step])
+            expect(logdata).to match(log_level_step.to_s.upcase)
           else
-            IO.read(@logfile).match(@messages[log_level_step]).should be nil
-            IO.read(@logfile).match(log_level_step.to_s.upcase).should be nil
+            expect(logdata).not_to match(messages[log_level_step])
+            expect(logdata).not_to match(log_level_step.to_s.upcase)
           end
         end
 

data/spec/ztk/parallel_spec.rb

@@ -27,7 +27,7 @@ describe ZTK::Parallel do
   describe "class" do
 
     it "should be an instance of ZTK::Parallel" do
-      subject.should be_an_instance_of ZTK::Parallel
+      expect(subject).to be_an_instance_of ZTK::Parallel
     end
 
   end
@@ -38,7 +38,7 @@ describe ZTK::Parallel do
     describe "#process" do
 
       it "should throw an exception if the process method is called without a block" do
-        lambda{ subject.process }.should raise_error ZTK::ParallelError, "You must supply a block to the process method!"
+        expect{ subject.process }.to raise_error ZTK::ParallelError
       end
 
       it "should spawn multiple processes to handle each iteration" do
@@ -50,14 +50,14 @@ describe ZTK::Parallel do
 
         subject.waitall
 
-        subject.results.all?{ |r| r.should be_kind_of Integer }
-        subject.results.all?{ |r| r.should > 0 }
-        subject.results.uniq.count.should == 3
-        subject.results.include?(Process.pid).should be false
+        subject.results.each{ |r| expect(r).to be_kind_of Integer }
+        subject.results.each{ |r| expect(r).to be > 0 }
+        expect(subject.results.uniq.count).to be == 3
+        expect(subject.results.include?(Process.pid)).to be == false
       end
 
       it "should stop all execution when the ZTK::Parallel::Break exception is raised" do
-        lambda {
+        expect do
 
           3.times do |x|
             subject.process do
@@ -67,11 +67,11 @@ describe ZTK::Parallel do
 
           subject.waitall
 
-          }.should raise_error
+        end.to raise_error ZTK::Parallel::Break
       end
 
       it "should stop all execution when any exception is raised" do
-        lambda {
+        expect do
           3.times do |x|
             subject.process do
               raise "SomeException"
@@ -79,13 +79,13 @@ describe ZTK::Parallel do
           end
 
           subject.waitall
-        }.should raise_error
+        end.to raise_error "SomeException"
       end
 
       it "should allow us to ignore exceptions" do
         subject = ZTK::Parallel.new(:raise_exceptions => false)
 
-        lambda {
+        expect do
           3.times do |x|
             subject.process do
               raise "SomeException"
@@ -93,13 +93,13 @@ describe ZTK::Parallel do
           end
 
           subject.waitall
-        }.should_not raise_error
+        end.not_to raise_error "SomeException"
       end
 
       it "should not ignore ZTK::Parallel::Break exceptions" do
         subject = ZTK::Parallel.new(:raise_exceptions => false)
 
-        lambda {
+        expect do
           3.times do |x|
             subject.process do
               raise ZTK::Parallel::Break
@@ -107,7 +107,7 @@ describe ZTK::Parallel do
           end
 
           subject.waitall
-        }.should raise_error
+        end.to raise_error ZTK::Parallel::Break
       end
 
     end
@@ -125,10 +125,10 @@ describe ZTK::Parallel do
           subject.wait
         end
 
-        subject.results.all?{ |r| r.should be_kind_of Integer }
-        subject.results.all?{ |r| r.should > 0 }
-        subject.results.uniq.count.should == 3
-        subject.results.include?(Process.pid).should be false
+        subject.results.each{ |r| expect(r).to be_kind_of Integer }
+        subject.results.each{ |r| expect(r).to be > 0 }
+        expect(subject.results.uniq.count).to be == 3
+        expect(subject.results.include?(Process.pid)).to be == false
       end
 
     end
@@ -143,7 +143,7 @@ describe ZTK::Parallel do
         end
 
         subject.waitall
-        subject.count.should == 0
+        expect(subject.count).to be == 0
       end
 
     end
@@ -159,7 +159,7 @@ describe ZTK::Parallel do
 
         expected_count = ((3 > ZTK::Parallel::MAX_FORKS) ? ZTK::Parallel::MAX_FORKS : 3)
 
-        subject.count.should == expected_count
+        expect(subject.count).to be == expected_count
         subject.waitall
       end
 

data/spec/ztk/profiler_spec.rb

@@ -0,0 +1,100 @@
+################################################################################
+#
+#      Author: Zachary Patten <zachary AT jovelabs DOT com>
+#   Copyright: Copyright (c) Zachary Patten
+#     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 "spec_helper"
+
+describe ZTK::Profiler do
+
+  let(:ui) { ZTK::UI.new(:stdout => StringIO.new, :stderr => StringIO.new, :stdin => StringIO.new) }
+
+  subject { ZTK::Profiler }
+
+  describe "class" do
+
+    it "should be ZTK::Profiler" do
+      expect(subject).to be ZTK::Profiler
+    end
+
+  end
+
+  before(:each) { subject.reset }
+
+  describe "methods" do
+
+    describe "#reset" do
+
+      it "should reset the timings" do
+        subject.start
+        sleep(0.5)
+        expect(subject.total_time).to be > 0.0
+        total_time = subject.total_time
+
+        subject.start
+        expect(subject.total_time).to be > 0.0
+        expect(subject.total_time).to be < total_time
+      end
+
+    end
+
+    describe "#start" do
+
+      it "should start the profiler" do
+        subject.start
+        expect(subject.total_time).to be > 0.0
+      end
+
+    end
+
+    describe "#total_time" do
+
+      it "should report the total time of the profiling" do
+        subject.start
+        expect(subject.total_time).to be > 0.0
+      end
+
+      it "should raise an exception if the profiler is not started first" do
+        expect{subject.total_time}.to raise_error ZTK::ProfilerError
+      end
+
+    end
+
+    describe "#report" do
+
+      it "should return a report of the profile timings" do
+        subject.start
+        subject.operation_a do
+          sleep(0.1)
+        end
+
+        report = subject.report(:ui => ui)
+
+        expect(report).to be_kind_of Array
+
+        expect(report.first).to be_kind_of Hash
+        expect(report.first.keys.first).to be == :operation_a
+        expect(report.first.values.first).to be_kind_of Float
+
+        expect(report.last).to be_kind_of Hash
+      end
+    end
+
+  end
+
+end