piggly-nsd 2.3.3

data/spec/examples/dumper/index_spec.rb

@@ -0,0 +1,199 @@
+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
+      allow(Config).to receive(:mkpath) { |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
+        expect(File).to receive(:exist?).with(@index.path).and_return(false)
+        expect(@index.procedures).to be_empty
+      end
+    end
+
+    context "when cache file exists" do
+      before do
+        allow(File).to receive(:exist?).with(@index.path).and_return(true)
+      end
+
+      context "when the cache index file is empty" do
+        it "is empty" do
+          allow(File).to receive(:read).and_return([].to_yaml)
+          expect(@index.procedures).to 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"
+
+          allow(File).to receive(:read) do |path, *args|
+            case path
+            when @first.source_path(@config)
+              @first.source(@config)
+            when @second.source_path(@config)
+              @second.source(@config)
+            when @index.path
+              YAML.dump([@first, @second])
+            end
+          end
+        end
+
+        it "has two procedures" do
+          expect(@index.procedures.size).to eq(2)
+        end
+
+        it "is indexed by identifier" do
+          expect(@index[@first.identifier].identifier).to eq(@first.identifier)
+          expect(@index[@second.identifier].identifier).to eq(@second.identifier)
+        end
+
+        it "reads each procedure's source_path" do
+          expect(@index[@first.identifier].source(@config)).to eq(@first.source(@config))
+          expect(@index[@second.identifier].source(@config)).to eq(@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 = double(: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
+            allow(@index).to receive(:procedures).and_return(
+              [ @procedure,
+                double(:oid  => 2,
+                     :name => q("public", "bar"),
+                     :type => q("private", "int"),
+                     :arg_modes => ["in"],
+                     :arg_names => [],
+                     :arg_types => []) ])
+          end
+
+          it "specifies schema.name" do
+            expect(@index.label(@procedure)).to eq("foo")
+          end
+        end
+
+        context "and there is more than one schema" do
+          before do
+            allow(@index).to receive(:procedures).and_return(
+              [ @procedure,
+                double(:oid  => 2,
+                     :name => q("schema", "foo"),
+                     :type => q("private", "int"),
+                     :arg_modes => ["in"],
+                     :arg_names => [],
+                     :arg_types => []) ])
+          end
+
+          it "specifies schema.name" do
+            expect(@index.label(@procedure)).to eq("public.foo")
+          end
+        end
+      end
+
+      context "when name is not unique" do
+        context "and schema.name is unique" do
+          before do
+            allow(@index).to receive(:procedures).and_return(
+              [ @procedure,
+                double(:oid  => 2,
+                     :name => q("schema", "foo"),
+                     :type => q("private", "int"),
+                     :arg_modes => ["in"],
+                     :arg_names => [],
+                     :arg_types => []) ])
+          end
+
+          it "specifies schema.name" do
+            expect(@index.label(@procedure)).to eq("public.foo")
+          end
+        end
+
+        context "and schema.name is not unique" do
+          context "but argument types are unique" do
+            before do
+              allow(@index).to receive(:procedures).and_return(
+                [ @procedure,
+                  double(:oid  => 2,
+                       :name => q("public", "foo"),
+                       :type => q("private", "int"),
+                       :arg_modes => ["in"],
+                       :arg_names => [],
+                       :arg_types => []) ])
+            end
+
+            it "specifies schema.name(types)" do
+              expect(@index.label(@procedure)).to eq(
+                "foo(private.int, private.varchar)")
+            end
+          end
+
+          context "and argument types are not unique" do
+            context "but argument modes are unique" do
+              before do
+                allow(@index).to receive(:procedures).and_return(
+                  [ @procedure,
+                    double(: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
+                expect(@index.label(@procedure)).to eq(
+                  "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/examples/grammar/expression_spec.rb

@@ -0,0 +1,302 @@
+require 'spec_helper'
+
+module Piggly
+  describe Parser, "expressions" do
+    include GrammarHelper
+
+    describe "expressionUntilSemiColon" do
+      it "does not consume semicolon" do
+        # parser stops in front of THEN and dies
+        expect{ parse(:expressionUntilSemiColon, 'abc;') }.to raise_error(Piggly::Parser::Failure)
+
+        node, rest = parse_some(:expressionUntilSemiColon, 'abc; xyz')
+        rest.should == '; xyz'
+      end
+
+      it "can be a blank expression" do
+        node, rest = parse_some(:expressionUntilSemiColon, ';')
+        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_expression
+        node.count{|e| e.comment? }.should == 1
+
+        node, rest = parse_some(:expressionUntilSemiColon, "-- comment\n;")
+        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_expression
+        node.count{|e| e.string? }.should == 1
+
+        node, rest = parse_some(:expressionUntilSemiColon, "$$ string $$;")
+        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_expression
+      end
+
+      it "can be an SQL statement" do
+        node, rest = parse_some(:expressionUntilSemiColon, "SELECT id FROM dataset;")
+        node.should be_expression
+      end
+
+      it "can be an expression with comments embedded" do
+        node, rest = parse_some(:expressionUntilSemiColon, <<-SQL)
+          SELECT id                    -- primary key ;
+          FROM "dataset" /* ; */       -- previous comments shouldn't terminate expression
+          WHERE value IS /*NOT*/ NULL;
+        SQL
+        node.should be_expression
+        node.count{|e| e.comment? }.should == 4
+      end
+
+      it "can be an expression with strings and comments embedded" do
+        node, rest = parse_some(:expressionUntilSemiColon, <<-SQL)
+          SELECT id    -- 1. upcoming single quote doesn't matter
+          FROM dataset /* 2. this one's no problem either */
+          WHERE value LIKE '/* comment within a string! shouldn''t parse a comment */'
+            AND length(value) > 10 -- 3. this comment in tail doesn't contain any 'string's
+            /* 4. farewell comment in tail */;
+        SQL
+        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
+        node, rest = parse_some(:expressionUntilSemiColon, <<-SQL)
+          SELECT id, created_at
+          FROM "dataset"
+          WHERE value IS NOT NULL
+            AND value <> '; this should not terminate expression'
+            AND created_at = '2001-01-01';
+        SQL
+        node.should be_expression
+        node.count{|e| e.string? }.should == 2
+      end
+
+      it "combines trailing whitespace into 'tail' node" do
+        node, rest = parse_some(:expressionUntilSemiColon, "a := x + y  \t;")
+        node.should be_expression
+        node.tail.source_text.should == "  \t"
+      end
+
+      it "combines trailing comments into 'tail' node" do
+        node, rest = parse_some(:expressionUntilSemiColon, "a := x + y /* note -- comment */;")
+        node.should be_expression
+        node.tail.source_text.should == ' /* note -- comment */'
+
+        node, rest = parse_some(:expressionUntilSemiColon, <<-SQL)
+          SELECT id    -- 1. upcoming single quote doesn't matter
+          FROM dataset /* 2. this one's no problem either */
+          WHERE value LIKE '/* comment within a string! shouldn''t parse a comment */'
+            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.comment? }.should == 2
+      end
+    end
+
+    describe "expressionUntilThen" do
+      it "does not consume THEN token" do
+        # parser stops in front of THEN and dies
+        expect{ parse(:expressionUntilThen, 'abc THEN') }.to raise_error(Piggly::Parser::Failure)
+
+        node, rest = parse_some(:expressionUntilThen, 'abc THEN xyz')
+        rest.should == 'THEN xyz'
+      end
+
+      it "cannot be a blank expression" do
+        expect{ parse_some(:expressionUntilThen, ' THEN') }.to raise_error(Piggly::Parser::Failure)
+      end
+
+      it "cannot be a comment" do
+        expect{ parse_some(:expressionUntilThen, "/* comment */ THEN") }.to raise_error(Piggly::Parser::Failure)
+        expect{ parse_some(:expressionUntilThen, "-- comment\n THEN") }.to raise_error(Piggly::Parser::Failure)
+      end
+
+      it "can be a string" do
+        node, rest = parse_some(:expressionUntilThen, "'string' THEN")
+        node.should be_expression
+        node.count{|e| e.string? }.should == 1
+
+        node, rest = parse_some(:expressionUntilThen, "$$ string $$ THEN")
+        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_expression
+      end
+
+      it "can be an SQL statement" do
+        node, rest = parse_some(:expressionUntilThen, "SELECT id FROM dataset THEN")
+        node.should be_expression
+      end
+
+      it "can be an expression with comments embedded" do
+        node, rest = parse_some(:expressionUntilThen, <<-SQL)
+          SELECT id                    -- primary key  THEN
+          FROM "dataset" /*  THEN */       -- previous comments shouldn't terminate expression
+          WHERE value IS /*NOT*/ NULL THEN
+        SQL
+        node.should be_expression
+        node.count{|e| e.comment? }.should == 4
+      end
+
+      it "can be an expression with strings and comments embedded" do
+        node, rest = parse_some(:expressionUntilThen, <<-SQL)
+          SELECT id    -- 1. upcoming single quote doesn't matter
+          FROM dataset /* 2. this one's no problem either */
+          WHERE value LIKE '/* comment within a string! shouldn''t parse a comment */'
+            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_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
+        node, rest = parse_some(:expressionUntilThen, <<-SQL)
+          SELECT id, created_at
+          FROM "dataset"
+          WHERE value IS NOT NULL
+            AND value <> ' THEN this should not terminate expression'
+            AND created_at = '2001-01-01' THEN
+        SQL
+        node.should be_expression
+        node.count{|e| e.string? }.should == 2
+      end
+
+      it "combines trailing whitespace into 'tail' node" do
+        node, rest = parse_some(:expressionUntilThen, "a := x + y  \tTHEN")
+        node.should be_expression
+        node.tail.source_text.should == "  \t"
+      end
+
+      it "combines trailing comments into 'tail' node" do
+        node, rest = parse_some(:expressionUntilThen, "a := x + y /* note -- comment */THEN")
+        node.should be_expression
+        node.tail.source_text.should == ' /* note -- comment */'
+
+        node, rest = parse_some(:expressionUntilThen, <<-SQL)
+          SELECT id    -- 1. upcoming single quote doesn't matter
+          FROM dataset /* 2. this one's no problem either */
+          WHERE value LIKE '/* comment within a string! shouldn''t parse a comment */'
+            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.comment? }.should == 2
+      end
+    end
+
+    describe "expressionUntilLoop" do
+      it "does not consume LOOP token" do
+        # parser stops in front of LOOP and dies
+        expect{ parse(:expressionUntilLoop, 'abc LOOP') }.to raise_error(Piggly::Parser::Failure)
+
+        node, rest = parse_some(:expressionUntilLoop, 'abc LOOP xyz')
+        rest.should == 'LOOP xyz'
+      end
+
+      it "cannot be a blank expression" do
+        expect{ parse_some(:expressionUntilLoop, ' LOOP') }.to raise_error(Piggly::Parser::Failure)
+      end
+
+      it "cannot be a comment" do
+        expect{ parse_some(:expressionUntilLoop, "/* comment */ LOOP") }.to raise_error(Piggly::Parser::Failure)
+        expect{ parse_some(:expressionUntilLoop, "-- comment\n LOOP") }.to raise_error(Piggly::Parser::Failure)
+      end
+
+      it "can be a string" do
+        node, rest = parse_some(:expressionUntilLoop, "'string' LOOP")
+        node.should be_expression
+        node.count{|e| e.string? }.should == 1
+
+        node, rest = parse_some(:expressionUntilLoop, "$$ string $$ LOOP")
+        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_expression
+      end
+
+      it "can be an SQL statement" do
+        node, rest = parse_some(:expressionUntilLoop, "SELECT id FROM dataset LOOP")
+        node.should be_expression
+      end
+
+      it "can be an expression with comments embedded" do
+        node, rest = parse_some(:expressionUntilLoop, <<-SQL)
+          SELECT id                    -- primary key  LOOP
+          FROM "dataset" /*  LOOP */       -- previous comments shouldn't terminate expression
+          WHERE value IS /*NOT*/ NULL LOOP
+        SQL
+        node.should be_expression
+        node.count{|e| e.comment? }.should == 4
+      end
+
+      it "can be an expression with strings and comments embedded" do
+        node, rest = parse_some(:expressionUntilLoop, <<-SQL)
+          SELECT id    -- 1. upcoming single quote doesn't matter
+          FROM dataset /* 2. this one's no problem either */
+          WHERE value LIKE '/* comment within a string! shouldn''t parse a comment */'
+            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_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
+        node, rest = parse_some(:expressionUntilLoop, <<-SQL)
+          SELECT id, created_at
+          FROM "dataset"
+          WHERE value IS NOT NULL
+            AND value <> ' LOOP this should not terminate expression'
+            AND created_at = '2001-01-01' LOOP
+        SQL
+        node.should be_expression
+        node.count{|e| e.string? }.should == 2
+      end
+
+      it "combines trailing whitespace into 'tail' node" do
+        node, rest = parse_some(:expressionUntilLoop, "a := x + y  \tLOOP")
+        node.should be_expression
+        node.tail.source_text.should == "  \t"
+      end
+
+      it "combines trailing comments into 'tail' node" do
+        node, rest = parse_some(:expressionUntilLoop, "a := x + y /* note -- comment */LOOP")
+        node.should be_expression
+        node.tail.source_text.should == ' /* note -- comment */'
+
+        node, rest = parse_some(:expressionUntilLoop, <<-SQL)
+          SELECT id    -- 1. upcoming single quote doesn't matter
+          FROM dataset /* 2. this one's no problem either */
+          WHERE value LIKE '/* comment within a string! shouldn''t parse a comment */'
+            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.comment? }.should == 2
+      end
+    end
+
+  end
+
+end

data/spec/examples/grammar/statements/assignment_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+module Piggly
+
+  describe Parser, "statements" do
+    include GrammarHelper
+
+    describe "assignment statements" do
+      it "parse successfully" do
+        node = parse(:statement, "a := 10;")
+        node.should be_statement
+        node.count{|e| e.assignment? }.should == 1
+
+        node.find{|e| e.named? :lval }.should be_a(Parser::Nodes::Assignable)
+        node.find{|e| e.named? :rval }.should be_expression
+      end
+
+      it "must end with a semicolon" do
+        expect { parse_some(:statement, 'a := 10') }.to raise_error(Piggly::Parser::Failure)
+        expect { parse(:statement, 'a := 10') }.to raise_error(Piggly::Parser::Failure)
+      end
+
+      it "can use := or =" do
+        a = parse(:statement, "a := 10;")
+        a.should be_statement
+        a.count{|e| e.assignment? }.should == 1
+
+        b = parse(:statement, "a = 10;")
+        b.should be_statement
+        b.count{|e| e.assignment? }.should == 1
+      end
+
+      it "can assign strings" do
+        node = parse(:statement, "a := 'string';")
+        rval = node.find{|e| e.named? :rval }
+        rval.count{|e| e.string? }.should == 1
+      end
+
+      it "can assign value expressions containing comments" do
+        ['a := /* comment */ 100;',
+         'a := 100 /* comment */;',
+         'a := 10 /* comment */ + 10;'].test_each do |s|
+          node = parse(:statement, s)
+          rval = node.find{|e| e.named? :rval }
+          rval.count{|e| e.comment? }.should == 1
+        end
+      end
+
+      it "can assign value expressions containing strings" do
+        node = parse(:statement, "a := 'Hello,' || space || 'world';")
+        rval = node.find{|e| e.named? :rval }
+        rval.count{|e| e.string? }.should == 2
+      end
+
+      it "can assign value expressions containing comments and strings" do
+        node = parse(:statement, <<-SQL.strip)
+          a := (SELECT fk, count(*), 'not a statement;'
+                FROM dataset
+                WHERE id > 100 /* filter out 'reserved' range */
+                  AND id < 900 -- shouldn't be a string
+                   OR value <> 'alpha /* no comment */;'
+                GROUP BY /* pk ; 'abc' */ fk);
+        SQL
+        rval = node.find{|e| e.named? :rval }
+        rval.count{|e| e.string? }.should == 2
+      end
+    end
+
+  end
+end