mortar 0.11.1 → 0.12.0

data/lib/mortar/pigversion.rb

@@ -0,0 +1,71 @@
+#
+# Copyright 2012 Mortar Data Inc.
+#
+# 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.
+#
+
+module Mortar
+	module PigVersion
+		PIG_0_9_TGZ_NAME = "pig-0.9.tar.gz"
+  		PIG_0_9_TGZ_DEFAULT_URL_PATH = "resource/pig_0_9"
+  		PIG_0_12_TGZ_NAME = "pig-0.12.tar.gz"
+  		PIG_0_12_TGZ_DEFAULT_URL_PATH = "resource/pig_0_12"
+
+  		def PigVersion.from_string(pig_version_str)
+  			if pig_version_str == '0.9'
+  				return Pig09.new
+  			elsif pig_version_str == '0.12'
+  				return Pig012.new
+  			else
+  				raise ArgumentError, "Unsupported pig version: #{pig_version_str}"
+  			end
+  		end
+
+		class Pig09
+			def tgz_name
+				PIG_0_9_TGZ_NAME
+			end
+
+			def tgz_default_url_path
+				PIG_0_9_TGZ_DEFAULT_URL_PATH
+			end
+
+			def name
+				"pig-#{version}"
+			end
+
+			def version
+				"0.9"
+			end
+		end
+
+		class Pig012
+			def tgz_name
+				PIG_0_12_TGZ_NAME
+			end
+
+			def tgz_default_url_path
+				PIG_0_12_TGZ_DEFAULT_URL_PATH
+			end
+
+			def name
+				"pig-#{version}"
+			end
+
+			def version
+				"0.12"
+			end
+		end
+
+	end
+end

data/lib/mortar/templates/script/runpig.sh

@@ -15,7 +15,7 @@ cd <%= @project_home %>/pigscripts
 source <%= @local_install_dir %>/pythonenv/bin/activate
 
 # Run Pig
-<%= @local_install_dir %>/pig-0.9/bin/pig -exectype local \
+<%= @local_install_dir %>/<%= @pig_dir %>/bin/pig -exectype local \
     -log4jconf <%= @log4j_conf %> \
     -propertyFile <%= @local_install_dir %>/lib-common/conf/pig-hawk-global.properties \
     -propertyFile <%= @local_install_dir %>/lib-common/conf/pig-cli-local-dev.properties \

data/lib/mortar/version.rb

@@ -16,5 +16,5 @@
 
 module Mortar
   # see http://semver.org/
-  VERSION = "0.11.1"
+  VERSION = "0.12.0"
 end

data/spec/mortar/command/base_spec.rb

@@ -78,5 +78,121 @@ other\tgit@github.com:other.git (push)
 
     end
 
+    context "method_added" do
+      it "replaces help templates" do
+        lines = Base.replace_templates(["line", "start <PIG_VERSION_OPTIONS>"])
+        #lines.join("").should == 'linestart 0.9 (default) and 0.12 (beta)'
+        lines.join("").should == 'line'
+      end
+    end
+
+    context "load_defaults" do
+      it "no errors with no .mortar-defaults file" do
+        with_git_initialized_project do |p|
+          b = Base.new
+          b.options.should == {}
+        end
+      end
+
+      it "loads default only params" do
+        with_git_initialized_project do |p|
+          text = """
+[DEFAULTS]
+pigversion=0.12
+
+[other]
+no_browser=True
+"""
+          write_file(File.join(p.root_path, ".mortar-defaults"), text)
+
+          b = Base.new
+          b.options.should == {:pigversion => "0.12"}
+        end
+      end
+
+      it "loads default only params with script" do
+        stub_core
+        git = Mortar::Git::Git.new
+
+        with_git_initialized_project do |p|
+          text = """
+[DEFAULTS]
+pigversion=0.12
+
+[other]
+no_browser=True
+"""
+          write_file(File.join(p.root_path, ".mortar-defaults"), text)
+
+          describe_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
+          describe_url = "https://api.mortardata.com/describe/#{describe_id}"
+
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_SUCCESS, "status_description" => "Success", "web_result_url" => describe_url})).ordered
+          mock(Launchy).open(describe_url) {Thread.new {}}
+
+          write_file(File.join(p.pigscripts_path, "my_script.pig"))
+
+          stderr, stdout, d = execute_and_return_command("describe pigscripts/my_script.pig my_alias --polling_interval 0.05", p, git)
+          d.options.should == {:pigversion => "0.12", :polling_interval => "0.05"}
+        end
+      end
+
+      it "loads params for script" do
+        stub_core
+        git = Mortar::Git::Git.new
+
+        with_git_initialized_project do |p|
+          text = """
+[DEFAULTS]
+pigversion=0.12
+
+[my_script]
+no_browser=True
+"""
+          write_file(File.join(p.root_path, ".mortar-defaults"), text)
+
+          describe_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
+          describe_url = "https://api.mortardata.com/describe/#{describe_id}"
+
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_SUCCESS, "status_description" => "Success", "web_result_url" => describe_url})).ordered
+          write_file(File.join(p.pigscripts_path, "my_script.pig"))
+
+          stderr, stdout, d = execute_and_return_command("describe pigscripts/my_script.pig my_alias --polling_interval 0.05", p, git)
+          d.options.should == {:pigversion => "0.12", :polling_interval => "0.05", :no_browser => "True"}
+        end
+      end
+
+      it "obeys proper overrides" do
+        stub_core
+        git = Mortar::Git::Git.new
+
+        with_git_initialized_project do |p|
+          text = """
+[DEFAULTS]
+clustersize=5
+no_browser=True
+
+[my_script]
+clustersize=10
+polling_interval=10
+"""
+          write_file(File.join(p.root_path, ".mortar-defaults"), text)
+
+          describe_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
+          describe_url = "https://api.mortardata.com/describe/#{describe_id}"
+
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_SUCCESS, "status_description" => "Success", "web_result_url" => describe_url})).ordered
+          write_file(File.join(p.pigscripts_path, "my_script.pig"))
+
+          stderr, stdout, d = execute_and_return_command("describe pigscripts/my_script.pig my_alias --polling_interval 0.05", p, git)
+          d.options.should == {:polling_interval => "0.05", :no_browser => "True", :clustersize => "10"}
+        end
+      end
+
+    end
+
   end
 end

data/spec/mortar/command/describe_spec.rb

@@ -96,7 +96,7 @@ STDERR
           describe_url = "https://api.mortardata.com/describe/#{describe_id}"
           parameters = ["name"=>"key", "value"=>"value" ]
           
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_GATEWAY_STARTING, "status_description" => "Gateway starting"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_PROGRESS, "status_description" => "Starting pig"})).ordered
@@ -127,7 +127,7 @@ STDOUT
           describe_url = "https://api.mortardata.com/describe/#{describe_id}"
           parameters = ["name"=>"key", "value"=>"value" ]
           
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_GATEWAY_STARTING, "status_description" => "Gateway starting"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_PROGRESS, "status_description" => "Starting pig"})).ordered
@@ -161,7 +161,7 @@ STDOUT
           column_number = 32
           error_type = 'PigError'
           
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :parameters => []) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :parameters => []) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_FAILURE, "status_description" => "Failed",
             "error_message" => error_message,
@@ -196,7 +196,7 @@ STDERR
           describe_url = "https://api.mortardata.com/describe/#{describe_id}"
           parameters = ["name"=>"key", "value"=>"value" ]
           
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_GATEWAY_STARTING, "status_description" => "Gateway starting"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_PROGRESS, "status_description" => "Starting pig"})).ordered

data/spec/mortar/command/illustrate_spec.rb

@@ -72,7 +72,7 @@ STDERR
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PROGRESS,         "status_description" => "In progress"})).ordered
@@ -106,7 +106,7 @@ STDOUT
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PROGRESS,         "status_description" => "In progress"})).ordered
@@ -140,7 +140,7 @@ STDOUT
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_SUCCESS,          "status_description" => "Succeeded", "web_result_url" => illustrate_url})).ordered
                     
@@ -167,7 +167,7 @@ STDOUT
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", true, is_a(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", true, is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_SUCCESS,          "status_description" => "Succeeded", "web_result_url" => illustrate_url})).ordered
                     
@@ -193,7 +193,7 @@ STDOUT
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", nil, false, is_a(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", nil, false, is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PROGRESS,         "status_description" => "In progress"})).ordered
@@ -230,7 +230,7 @@ STDOUT
           error_type = 'PigError'
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :parameters => []) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.9", :parameters => []) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,  "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_FAILURE, 
             "error_message" => error_message,
@@ -266,7 +266,7 @@ STDERR
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", nil, false, is_a(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", nil, false, is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PROGRESS,         "status_description" => "In progress"})).ordered

data/spec/mortar/command/jobs_spec.rb

@@ -47,6 +47,7 @@ module Mortar::Command
           cluster_size = 5
 
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
+            :pig_version => "0.9", 
             :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__SINGLE_JOB,
             :notify_on_job_finish => true,
@@ -79,7 +80,8 @@ STDOUT
           job_url = "http://127.0.0.1:5000/jobs/job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5"
           cluster_size = 5
 
-          mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size,
+          mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String),cluster_size,
+                                                      :pig_version => "0.9", 
                                                       :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]),
                                                       :cluster_type => Jobs::CLUSTER_TYPE__PERMANENT,
                                                       :notify_on_job_finish => true,
@@ -136,7 +138,8 @@ STDERR
           job_url = "http://127.0.0.1:5000/jobs/job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5"
           cluster_size = 5
 
-          mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
+          mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String),cluster_size, 
+            :pig_version => "0.9", 
             :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,
@@ -170,6 +173,7 @@ STDOUT
           cluster_id = "e2790e7e8c7d48e39157238d58191346"
 
           mock(Mortar::Auth.api).post_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id,
+              :pig_version => "0.9", 
               :parameters => [],
               :notify_on_job_finish => false,
               :is_control_script=>true) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
@@ -202,6 +206,7 @@ STDOUT
           cluster_id = "e2790e7e8c7d48e39157238d58191346"
 
           mock(Mortar::Auth.api).post_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id,
+              :pig_version => "0.9", 
               :parameters => [],
               :notify_on_job_finish => false,
               :is_control_script=>true) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
@@ -234,6 +239,7 @@ STDOUT
 
           mock(Mortar::Auth.api).get_clusters() {Excon::Response.new(:body => {'clusters' => []})}
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
+            :pig_version => "0.9", 
             :parameters => [], 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,
@@ -269,6 +275,7 @@ STDOUT
 
           mock(Mortar::Auth.api).get_clusters() {Excon::Response.new(:body => {'clusters' => []})}
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
+            :pig_version => "0.9", 
             :parameters => [], 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,
@@ -303,7 +310,7 @@ STDOUT
           job_url = "http://127.0.0.1:5000/jobs/job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5"
           cluster_id = "e2790e7e8c7d48e39157238d58191346"
 
-          mock(Mortar::Auth.api).post_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id, :parameters => [], :notify_on_job_finish => false, :is_control_script=>false) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
+          mock(Mortar::Auth.api).post_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id, :pig_version => "0.9", :parameters => [], :notify_on_job_finish => false, :is_control_script=>false) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
 
           write_file(File.join(p.pigscripts_path, "my_script.pig"))
           stderr, stdout = execute("jobs:run pigscripts/my_script.pig --clusterid e2790e7e8c7d48e39157238d58191346 -d", p, @git)
@@ -356,6 +363,7 @@ STDOUT
               ]})
           }
           mock(Mortar::Auth.api).post_job_existing_cluster("myproject", "my_script", is_a(String), large_cluster_id, 
+            :pig_version => "0.9", 
             :parameters => [], 
             :notify_on_job_finish => true,
             :is_control_script=>false) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
@@ -388,6 +396,7 @@ STDOUT
           cluster_size = 5
 
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
+            :pig_version => "0.9", 
             :parameters => match_array([{"name" => "FIRST", "value" => "FOO"}, {"name" => "SECOND", "value" => "BAR"}, {"name" => "THIRD", "value" => "BEAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,
@@ -413,6 +422,7 @@ PARAMS
           cluster_size = 5
 
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
+            :pig_version => "0.9", 
             :parameters => match_array([{"name" => "FIRST", "value" => "FOO"}, {"name" => "SECOND", "value" => "BAR"}, {"name" => "THIRD", "value" => "BEAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,
@@ -466,6 +476,7 @@ STDERR
           mock(@git).sync_embedded_project.with_any_args.times(1) { "somewhere_over_the_rainbow" }
 
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
+            :pig_version => "0.9", 
             :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,

data/spec/mortar/command/local_spec.rb

@@ -44,7 +44,7 @@ STDERR
           pigscript = Mortar::Project::PigScript.new(script_name, script_path)
           mock(Mortar::Project::PigScript).new(script_name, script_path).returns(pigscript)
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).illustrate(pigscript, "some_alias", [], false).returns(nil)
+            mock(u).illustrate(pigscript, "some_alias", is_a(Mortar::PigVersion::Pig09), [], false).returns(nil)
           end
           stderr, stdout = execute("local:illustrate #{script_name} some_alias", p)
           stderr.should == ""
@@ -59,9 +59,9 @@ STDERR
           pigscript = Mortar::Project::PigScript.new(script_name, script_path)
           mock(Mortar::Project::PigScript).new(script_name, script_path).returns(pigscript)
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).illustrate(pigscript, nil, [], false).returns(nil)
+            mock(u).illustrate(pigscript, nil, is_a(Mortar::PigVersion::Pig012), [], false).returns(nil)
           end
-          stderr, stdout = execute("local:illustrate #{script_name}", p)
+          stderr, stdout = execute("local:illustrate #{script_name} -g 0.12", p)
           stderr.should == ""
         end
       end
@@ -96,9 +96,9 @@ STDERR
           pigscript = Mortar::Project::PigScript.new(script_name, script_path)
           mock(Mortar::Project::PigScript).new(script_name, script_path).returns(pigscript)
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).run(pigscript, []).returns(nil)
+            mock(u).run(pigscript, is_a(Mortar::PigVersion::Pig09), []).returns(nil)
           end
-          stderr, stdout = execute("local:run pigscripts/#{script_name}.pig", p)
+          stderr, stdout = execute("local:run pigscripts/#{script_name}.pig -g 0.9", p)
           stderr.should == ""
         end
       end
@@ -167,7 +167,7 @@ PARAMS
           mock(j).check_install.returns(true)
         end
         any_instance_of(Mortar::Local::Pig) do |j|
-          mock(j).install_pig.returns(true)
+          mock(j).install_pig.with_any_args.returns(true)
           stub(j).install_lib.returns(true)
         end
         any_instance_of(Mortar::Local::Python) do |j|
@@ -198,10 +198,10 @@ PARAMS
           pigscript = Mortar::Project::PigScript.new(script_name, script_path)
           mock(Mortar::Project::PigScript).new(script_name, script_path).returns(pigscript)
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).install_and_configure
+            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig09))
           end
           any_instance_of(Mortar::Local::Pig) do |u|
-            mock(u).run_pig_command(" -check #{pigscript.path}", [])
+            mock(u).run_pig_command(" -check #{pigscript.path}", is_a(Mortar::PigVersion::Pig09), [])
           end
           stderr, stdout = execute("local:validate #{script_name}", p)
           stderr.should == ""
@@ -216,10 +216,10 @@ PARAMS
           pigscript = Mortar::Project::PigScript.new(script_name, script_path)
           mock(Mortar::Project::PigScript).new(script_name, script_path).returns(pigscript)
           any_instance_of(Mortar::Local::Controller) do |u|
-            mock(u).install_and_configure
+            mock(u).install_and_configure(is_a(Mortar::PigVersion::Pig09))
           end
           any_instance_of(Mortar::Local::Pig) do |u|
-            mock(u).run_pig_command(" -check #{pigscript.path}", [])
+            mock(u).run_pig_command(" -check #{pigscript.path}", is_a(Mortar::PigVersion::Pig09), [])
           end
           stderr, stdout = execute("local:validate pigscripts/#{script_name}.pig", p)
           stderr.should == ""