piggly 1.2.1 → 2.0.0

data/spec/examples/config_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+module Piggly
+
+describe Config do
+  before do
+    @config = Config.new
+  end
+
+  it "has class accessors and mutators" do
+    @config.should respond_to(:cache_root)
+    @config.should respond_to(:cache_root=)
+    @config.should respond_to(:report_root)
+    @config.should respond_to(:report_root=)
+    @config.should respond_to(:trace_prefix)
+    @config.should respond_to(:trace_prefix=)
+  end
+
+  it "has default values" do
+    @config.cache_root = nil
+    @config.cache_root.should_not be_nil
+    @config.cache_root.should =~ /cache$/
+
+    @config.report_root = nil
+    @config.report_root.should_not be_nil
+    @config.report_root.should =~ /reports$/
+
+    @config.trace_prefix = nil
+    @config.trace_prefix.should_not be_nil
+    @config.trace_prefix.should == 'PIGGLY'
+  end
+  
+  describe "path" do
+    it "doesn't reparent absolute paths" do
+      @config.path('/tmp', '/usr/bin/ps').should == '/usr/bin/ps'
+      @config.path('A:/data/tmp', 'C:/USER/tmp').should == 'C:/USER/tmp'
+      @config.path('/tmp/data', '../data.txt').should == '../data.txt'
+    end
+    
+    it "reparents relative paths" do
+      @config.path('/tmp', 'note.txt').should == '/tmp/note.txt'
+    end
+    
+    it "doesn't require path parameter" do
+      @config.path('/tmp').should == '/tmp'
+    end
+  end
+  
+  describe "mkpath" do
+    it "creates root if doesn't exist" do
+      FileUtils.should_receive(:makedirs).with('x/y').once.and_return(true)
+      @config.mkpath('x/y', 'z')
+    end
+
+    it "throws an error on path components that exist as files" do
+      lambda { @config.mkpath('/etc/passwd/file') }.should raise_error(Errno::EEXIST)
+    end
+  end
+end
+
+end

data/spec/examples/dumper/index_spec.rb

@@ -0,0 +1,197 @@
+require "spec_helper"
+
+module Piggly
+
+  describe Dumper::Index do
+    before do
+      # make sure not to create directories all over the file system during the test
+      Config.stub(:mkpath).and_return{|root, file| File.join(root, file) }
+
+      @config = Config.new
+      @index  = Dumper::Index.new(@config)
+    end
+
+    context "when cache file doesn't exist" do
+      it "is empty" do
+        File.should_receive(:exists?).with(@index.path).and_return(false)
+        @index.procedures.should be_empty
+      end
+    end
+
+    context "when cache file exists" do
+      before do
+        File.stub(:exists?).with(@index.path).and_return(true)
+      end
+
+      context "when the cache index file is empty" do
+        it "is empty" do
+          File.should_receive(:read).with(@index.path).and_return([].to_yaml)
+          @index.procedures.should be_empty
+        end
+      end
+
+      context "when the cache index file has two entries" do
+        before do
+          @first  = Dumper::ReifiedProcedure.from_hash \
+            "oid"    => "1000",
+            "name"   => "iterate",
+            "source" => "FIRST PROCEDURE SOURCE CODE"
+
+          @second = Dumper::ReifiedProcedure.from_hash \
+            "oid"    => "2000",
+            "name"   => "login",
+            "source" => "SECOND PROCEDURE SOURCE CODE"
+
+          File.stub(:read).with(@first.source_path(@config)).
+            and_return(@first.source(@config))
+
+          File.stub(:read).with(@second.source_path(@config)).
+            and_return(@second.source(@config))
+
+          File.stub(:read).with(@index.path).
+            and_return(YAML.dump([@first, @second]))
+        end
+
+        it "has two procedures" do
+          @index.procedures.should have(2).things
+        end
+
+        it "is indexed by identifier" do
+          @index[@first.identifier].identifier.should == @first.identifier
+          @index[@second.identifier].identifier.should == @second.identifier
+        end
+
+        it "reads each procedure's source_path" do
+          @index[@first.identifier].source(@config).should == @first.source(@config)
+          @index[@second.identifier].source(@config).should == @second.source(@config)
+        end
+
+        context "when the procedures used to be identified using another method" do
+          it "renames each procedure using the current identifier"
+          it "updates the index with the current identified_using"
+          it "writes the updated index to disk"
+        end
+      end
+    end
+
+    describe "update" do
+      it "caches the source of new procedures"
+      it "updates the cached source of updated procedures"
+      it "purges the cached source of outdated procedures"
+      it "writes the cache index to disk"
+      it "does not write procedure source code within the cache index"
+    end
+
+    describe "label" do
+      def q(*ns)
+        Dumper::QualifiedName.new(*ns)
+      end
+
+      before do
+        @procedure = mock(:oid  => 1,
+                          :name => q("public", "foo"),
+                          :type => q("private", "int"),
+                          :arg_modes => ["in", "in"],
+                          :arg_names => [],
+                          :arg_types => [q("private", "int"), q("private", "varchar")])
+      end
+
+      context "when name is unique" do
+        context "and there is only one schema" do
+          before do
+            @index.stub(:procedures =>
+              [ @procedure,
+                mock(:oid  => 2,
+                     :name => q("public", "bar"),
+                     :type => q("private", "int"),
+                     :arg_modes => ["in"],
+                     :arg_names => [],
+                     :arg_types => []) ])
+          end
+
+          it "specifies schema.name" do
+            @index.label(@procedure).should == "foo"
+          end
+        end
+
+        context "and there is more than one schema" do
+          before do
+            @index.stub(:procedures =>
+              [ @procedure,
+                mock(:oid  => 2,
+                     :name => q("schema", "foo"),
+                     :type => q("private", "int"),
+                     :arg_modes => ["in"],
+                     :arg_names => [],
+                     :arg_types => []) ])
+          end
+
+          it "specifies schema.name" do
+            @index.label(@procedure).should == "public.foo"
+          end
+        end
+      end
+
+      context "when name is not unique" do
+        context "and schema.name is unique" do
+          before do
+            @index.stub(:procedures =>
+              [ @procedure,
+                mock(:oid  => 2,
+                     :name => q("schema", "foo"),
+                     :type => q("private", "int"),
+                     :arg_modes => ["in"],
+                     :arg_names => [],
+                     :arg_types => []) ])
+          end
+
+          it "specifies schema.name" do
+            @index.label(@procedure).should == "public.foo"
+          end
+        end
+
+        context "and schema.name is not unique" do
+          context "but argument types are unique" do
+            before do
+              @index.stub(:procedures =>
+                [ @procedure,
+                  mock(:oid  => 2,
+                       :name => q("public", "foo"),
+                       :type => q("private", "int"),
+                       :arg_modes => ["in"],
+                       :arg_names => [],
+                       :arg_types => []) ])
+            end
+
+            it "specifies schema.name(types)" do
+              @index.label(@procedure).should ==
+                "foo(private.int, private.varchar)"
+            end
+          end
+
+          context "and argument types are not unique" do
+            context "but argument modes are unique" do
+              before do
+                @index.stub(:procedures =>
+                  [ @procedure,
+                    mock(:oid  => 2,
+                         :name => q("public", "foo"),
+                         :type => q("private", "int"),
+                         :arg_modes => ["out", "out"],
+                         :arg_names => [],
+                         :arg_types => [q("private", "int"), q("private", "varchar")]) ])
+              end
+
+              it "specifies schema.name(types and modes)" do
+                @index.label(@procedure).should ==
+                  "foo(in private.int, in private.varchar)"
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/spec/examples/dumper/procedure_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+module Piggly
+  
+  describe Dumper::ReifiedProcedure do
+    describe "all" do
+      before do
+        # stub connection
+      end
+    end
+
+    describe "from_hash" do
+      it "abbreviates known return types"
+      it "leaves alone unknown argument types"
+
+      it "abbreviates known return types"
+      it "leaves alone unknown argument types"
+
+      it "maps known volatilities"
+      it "leaves alone unknown volatilities"
+
+      it "maps known argument modes"
+      it "leaves alone unknown argument modes"
+    end
+
+    describe "store_source" do
+      context "when source is already instrumented" do
+        it "raises an error"
+      end
+
+      context "when the procedure was identified using the current configuration setting" do
+        it "does not attempt to remove any files"
+        it "writes to the current location"
+        it "has the current identified_using property"
+      end
+
+      context "when the procedure was identified using some other configuration setting" do
+        it "removes any old report files"
+        it "removes any old trace cache files"
+        it "removes the old source cache files"
+        it "writes to the current location"
+        it "updates the identified_using property"
+      end
+    end
+  end
+
+  describe Dumper::SkeletonProcedure do
+    describe "definition" do
+      it "specifies namespace and function name"
+      it "specifies source code between dollar-quoted string tags"
+
+      context "with argument modes" do
+        it "specifies argument modes"
+      end
+
+      context "without argument modes" do
+        it "doesn't specify argument modes"
+      end
+
+      context "with strict modifier" do
+        it "specifies STRICT token"
+      end
+
+      context "without strict modifier" do
+        it "doesn't specify STRICT token"
+      end
+
+      context "with security definer modifier" do
+        it "specifies SECURITY DEFINER token"
+      end
+
+      context "without security definer modifier" do
+        it "doesn't specify SECURITY DEFINER token"
+      end
+
+      context "with set-returning type" do
+        it "specifies SETOF token"
+      end
+
+      context "without non set-returning type" do
+        it "doesn't specify SETOF token"
+      end
+
+      context "with stable volatility" do
+        it "specifies STABLE token"
+      end
+    end
+
+    describe "source_path" do
+      it "has a .plpgsql extension"
+      it "is within the Dumper directory"
+    end
+
+    describe "purge_source" do
+      context "when the procedure was identified using the current configuration setting" do
+        it "removes any old report files"
+        it "removes any old trace cache files"
+        it "removes the old source cache files"
+        it "removes the current report files"
+        it "removes the current trace cache files"
+        it "removes the current source cache files"
+        it "doesn't attempt to remove any other files"
+      end
+
+      context "when the procedure was identified using some other configuration setting" do
+        it "removes the current report files"
+        it "removes the current trace cache files"
+        it "removes the current source cache files"
+        it "doesn't attempt to remove any other files"
+      end
+    end
+
+    describe "equality operator"
+  end
+
+end

data/spec/{grammar → examples/grammar}/expression_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require 'spec_helper'
 
 module Piggly
   describe Parser, "expressions" do
@@ -15,39 +15,39 @@ module Piggly
 
       it "can be a blank expression" do
         node, rest = parse_some(:expressionUntilSemiColon, ';')
-        node.should be_a(Expression)
+        node.should be_expression
         node.source_text.should == ''
         rest.should == ';'
       end
 
       it "can be a comment" do
         node, rest = parse_some(:expressionUntilSemiColon, "/* comment */;")
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TComment) }.should == 1
+        node.should be_expression
+        node.count{|e| e.comment? }.should == 1
 
         node, rest = parse_some(:expressionUntilSemiColon, "-- comment\n;")
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TComment) }.should == 1
+        node.should be_expression
+        node.count{|e| e.comment? }.should == 1
       end
 
       it "can be a string" do
         node, rest = parse_some(:expressionUntilSemiColon, "'string';")
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TString) }.should == 1
+        node.should be_expression
+        node.count{|e| e.string? }.should == 1
 
         node, rest = parse_some(:expressionUntilSemiColon, "$$ string $$;")
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TString) }.should == 1
+        node.should be_expression
+        node.count{|e| e.string? }.should == 1
       end
 
       it "can be an arithmetic expression" do
         node, rest = parse_some(:expressionUntilSemiColon, "10 * (3 + x);")
-        node.should be_a(Expression)
+        node.should be_expression
       end
 
       it "can be an SQL statement" do
         node, rest = parse_some(:expressionUntilSemiColon, "SELECT id FROM dataset;")
-        node.should be_a(Expression)
+        node.should be_expression
       end
 
       it "can be an expression with comments embedded" do
@@ -56,8 +56,8 @@ module Piggly
           FROM "dataset" /* ; */       -- previous comments shouldn't terminate expression
           WHERE value IS /*NOT*/ NULL;
         SQL
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TComment) }.should == 4
+        node.should be_expression
+        node.count{|e| e.comment? }.should == 4
       end
 
       it "can be an expression with strings and comments embedded" do
@@ -68,9 +68,9 @@ module Piggly
             AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
             /* 4. farewell comment in tail */;
         SQL
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TComment) }.should == 4
-        node.count{|e| e.is_a?(TString) }.should == 1
+        node.should be_expression
+        node.count{|e| e.comment? }.should == 4
+        node.count{|e| e.string? }.should == 1
       end
 
       it "can be an expression with strings embedded" do
@@ -81,19 +81,19 @@ module Piggly
             AND value <> '; this should not terminate expression'
             AND created_at = '2001-01-01';
         SQL
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TString) }.should == 2
+        node.should be_expression
+        node.count{|e| e.string? }.should == 2
       end
 
-      it "should combine trailing whitespace into 'tail' node" do
+      it "combines trailing whitespace into 'tail' node" do
         node, rest = parse_some(:expressionUntilSemiColon, "a := x + y  \t;")
-        node.should be_a(Expression)
+        node.should be_expression
         node.tail.source_text.should == "  \t"
       end
 
-      it "should combine trailing comments into 'tail' node" do
+      it "combines trailing comments into 'tail' node" do
         node, rest = parse_some(:expressionUntilSemiColon, "a := x + y /* note -- comment */;")
-        node.should be_a(Expression)
+        node.should be_expression
         node.tail.source_text.should == ' /* note -- comment */'
 
         node, rest = parse_some(:expressionUntilSemiColon, <<-SQL)
@@ -103,7 +103,7 @@ module Piggly
             AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
             /* 4. farewell comment in tail */;
         SQL
-        node.tail.count{|e| e.is_a?(TComment) }.should == 2
+        node.tail.count{|e| e.comment? }.should == 2
       end
     end
 
@@ -127,22 +127,22 @@ module Piggly
 
       it "can be a string" do
         node, rest = parse_some(:expressionUntilThen, "'string' THEN")
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TString) }.should == 1
+        node.should be_expression
+        node.count{|e| e.string? }.should == 1
 
         node, rest = parse_some(:expressionUntilThen, "$$ string $$ THEN")
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TString) }.should == 1
+        node.should be_expression
+        node.count{|e| e.string? }.should == 1
       end
 
       it "can be an arithmetic expression" do
         node, rest = parse_some(:expressionUntilThen, "10 * (3 + x) THEN")
-        node.should be_a(Expression)
+        node.should be_expression
       end
 
       it "can be an SQL statement" do
         node, rest = parse_some(:expressionUntilThen, "SELECT id FROM dataset THEN")
-        node.should be_a(Expression)
+        node.should be_expression
       end
 
       it "can be an expression with comments embedded" do
@@ -151,8 +151,8 @@ module Piggly
           FROM "dataset" /*  THEN */       -- previous comments shouldn't terminate expression
           WHERE value IS /*NOT*/ NULL THEN
         SQL
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TComment) }.should == 4
+        node.should be_expression
+        node.count{|e| e.comment? }.should == 4
       end
 
       it "can be an expression with strings and comments embedded" do
@@ -163,9 +163,9 @@ module Piggly
             AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
             /* 4. farewell comment in tail */ THEN
         SQL
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TComment) }.should == 4
-        node.count{|e| e.is_a?(TString) }.should == 1
+        node.should be_expression
+        node.count{|e| e.comment? }.should == 4
+        node.count{|e| e.string? }.should == 1
       end
 
       it "can be an expression with strings embedded" do
@@ -176,19 +176,19 @@ module Piggly
             AND value <> ' THEN this should not terminate expression'
             AND created_at = '2001-01-01' THEN
         SQL
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TString) }.should == 2
+        node.should be_expression
+        node.count{|e| e.string? }.should == 2
       end
 
-      it "should combine trailing whitespace into 'tail' node" do
+      it "combines trailing whitespace into 'tail' node" do
         node, rest = parse_some(:expressionUntilThen, "a := x + y  \tTHEN")
-        node.should be_a(Expression)
+        node.should be_expression
         node.tail.source_text.should == "  \t"
       end
 
-      it "should combine trailing comments into 'tail' node" do
+      it "combines trailing comments into 'tail' node" do
         node, rest = parse_some(:expressionUntilThen, "a := x + y /* note -- comment */THEN")
-        node.should be_a(Expression)
+        node.should be_expression
         node.tail.source_text.should == ' /* note -- comment */'
 
         node, rest = parse_some(:expressionUntilThen, <<-SQL)
@@ -198,7 +198,7 @@ module Piggly
             AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
             /* 4. farewell comment in tail */THEN
         SQL
-        node.tail.count{|e| e.is_a?(TComment) }.should == 2
+        node.tail.count{|e| e.comment? }.should == 2
       end
     end
 
@@ -222,22 +222,22 @@ module Piggly
 
       it "can be a string" do
         node, rest = parse_some(:expressionUntilLoop, "'string' LOOP")
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TString) }.should == 1
+        node.should be_expression
+        node.count{|e| e.string? }.should == 1
 
         node, rest = parse_some(:expressionUntilLoop, "$$ string $$ LOOP")
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TString) }.should == 1
+        node.should be_expression
+        node.count{|e| e.string? }.should == 1
       end
 
       it "can be an arithmetic expression" do
         node, rest = parse_some(:expressionUntilLoop, "10 * (3 + x) LOOP")
-        node.should be_a(Expression)
+        node.should be_expression
       end
 
       it "can be an SQL statement" do
         node, rest = parse_some(:expressionUntilLoop, "SELECT id FROM dataset LOOP")
-        node.should be_a(Expression)
+        node.should be_expression
       end
 
       it "can be an expression with comments embedded" do
@@ -246,8 +246,8 @@ module Piggly
           FROM "dataset" /*  LOOP */       -- previous comments shouldn't terminate expression
           WHERE value IS /*NOT*/ NULL LOOP
         SQL
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TComment) }.should == 4
+        node.should be_expression
+        node.count{|e| e.comment? }.should == 4
       end
 
       it "can be an expression with strings and comments embedded" do
@@ -258,9 +258,9 @@ module Piggly
             AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
             /* 4. farewell comment in tail */ LOOP
         SQL
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TComment) }.should == 4
-        node.count{|e| e.is_a?(TString) }.should == 1
+        node.should be_expression
+        node.count{|e| e.comment? }.should == 4
+        node.count{|e| e.string? }.should == 1
       end
 
       it "can be an expression with strings embedded" do
@@ -271,19 +271,19 @@ module Piggly
             AND value <> ' LOOP this should not terminate expression'
             AND created_at = '2001-01-01' LOOP
         SQL
-        node.should be_a(Expression)
-        node.count{|e| e.is_a?(TString) }.should == 2
+        node.should be_expression
+        node.count{|e| e.string? }.should == 2
       end
 
-      it "should combine trailing whitespace into 'tail' node" do
+      it "combines trailing whitespace into 'tail' node" do
         node, rest = parse_some(:expressionUntilLoop, "a := x + y  \tLOOP")
-        node.should be_a(Expression)
+        node.should be_expression
         node.tail.source_text.should == "  \t"
       end
 
-      it "should combine trailing comments into 'tail' node" do
+      it "combines trailing comments into 'tail' node" do
         node, rest = parse_some(:expressionUntilLoop, "a := x + y /* note -- comment */LOOP")
-        node.should be_a(Expression)
+        node.should be_expression
         node.tail.source_text.should == ' /* note -- comment */'
 
         node, rest = parse_some(:expressionUntilLoop, <<-SQL)
@@ -293,7 +293,7 @@ module Piggly
             AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
             /* 4. farewell comment in tail */LOOP
         SQL
-        node.tail.count{|e| e.is_a?(TComment) }.should == 2
+        node.tail.count{|e| e.comment? }.should == 2
       end
     end