From 7cdeb5e42a2f16babc2b68bb026e58bb783da904 Mon Sep 17 00:00:00 2001
From: Dhvani Patel <dhvanipatel_2000@yahoo.ca>
Date: Thu, 27 Jul 2017 14:50:21 -0600
Subject: [PATCH] Fixed up sub to make sub for every window

---
 __pycache__/toCheck.pypy-41.pyc | Bin 2604 -> 15515 bytes
 mutate_token_sub.py             | 206 ++++++++++++
 mutate_token_sub.pyc            | Bin 3754 -> 6332 bytes
 py_mutations_hub.py             |  74 +++--
 toCheck.py                      | 570 ++++++++++++++++++++++++++++++++
 5 files changed, 825 insertions(+), 25 deletions(-)
 create mode 100644 toCheck.py

diff --git a/__pycache__/toCheck.pypy-41.pyc b/__pycache__/toCheck.pypy-41.pyc
index 462cb2f93cfeef90406e38e7c6a5f31b6924e241..7002a4437dfb5f9e9608ffbaaf31b3e5d7cc0277 100644
GIT binary patch
literal 15515
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
JmEu|Je*pPF-r)cM

literal 2604
zcmcIm+in|G6x}nv#CDP<ZRsVXrIr9;gwpf@DkP#Jl!P`Cvcx1&sb5AD&v82Gc*e{*
z7NknVL-_>W_#xci;R9f;Jx-iNh)PJ<o;~|q_ie3n-1>8|_2|~?7k!z2YSXv<1xk#c
zC#gtJ<aqh4=}FI*=h=O!nu@$?N%56<o;RKAb1?Jd2ey4lt1_%fuO>QPk+d$uIqA*G
zupzw$daGhYj+!#?B(BM?B5y=q^jfsL+o{8c<S%@>9S^FbbK`Lmf8O!gtUyGgkz*r1
zaM$sAW}?C!n8@uJ>oy~6&I98HoM^v*fXyBZ3Jt<v7^705$5g5kS5&D<Tveqm!ET4<
z``m|570)IfdjjF`^W;c(+JIlvhA$h?CRKSWf@z`05L}%xzCr&S`(dfgv4$i%>8L@Q
zkCBYHF7cck!mEZn=9DI<#7&7?WgA%%WN97_bln`}-uCX^PWP!>g#OL`-m@^+{(gTa
z*xpJSbdu@Ji{voLG<AbK*Y^QZ##A0euN|Xu(V?}=P>|a+=|?Wfv-KmJXLbRdn|bC;
z=GNTt$f#*uvsa8wpf#eAex41ILoL_0QEH8&iw+eD`)Pv3YR<YMK=-t&qmd~Bu60d_
zmuF?vu+WN4VM`3qLu=AO2X9f~TF_j+`O@@XJscgYS=ihkEph4%&hr<&MQ_Q!=U2Rz
zce_&Y&dW$hXc@0TK^Z3=i$b*Ss=cm4El|ACPK+pu{5XscbU3()zL_h*d)!5njR>~#
zpRzVOELV%KHt9Y~r8a*@#!%QJH46{|egN~NqMbkudP=<p-9Po%KdH+Jpf*R8y!FN7
zf`)cAWdcNSDu1W`*=(S)E-Qf23T@5nDsHqOC)1%uIRw~4<E9*F%F1bJ{eN_CQBGiE
z>IN*T@iHUVh;xkIVK7%hFN1hT=>M|!(mVH701)q8%d)S}5XlP0k&6N%E15u8J(t{I
z?aP2?kit0NDm|H!*b@G;9oCaS(C(07C1tqdD7Q|TM4~B#<MD80%MEEsITTrI3b*~^
zI7+o`UF60#?B}u3HEABjHn_{_<Wg)nQqqcKD3^bi*y$FG@4}W=d3k8uba85&>Cibv
zxx%_Ic7%h#ls35jJTYMsUnPQainKqU^buCrHiT5xyqn%Cz7PD?RKHuft$lneS;!mO
zSF(Hx<sw;TumIA*2tB=tpP1a`f!4KmATK07&W+7-XMRQolHWkSGCH1H!G{$0DL#NG
zSx<5YAG3+46eYto!<PaJv2QrY$65R}rdoO}{*5vW`ZD7@8W+R(FPxvQ$4#MZzsipK
z`N7cC%(P@O&#UCp!BDavd@nDQx0Pw)^ftMId9C&ZykEw%RXoo~ph$GNi&9)y$c3JX
zY_`u~VB1gHk2<`jlmWr})K)3(Q7DTD`dLBB`aEDClOMDp^qwp6`?SEFZwf8DqE*YL
zQ?J&JMb*0qK%W8AZlPN*I7KE(M|5^rHU)kdX3@}up<Xs&ILza5ie_*N69U34_=JMS
zg3lmkR#j8j1Ox(u*7Vl>=JjT^x!SCi*JuL+<1BIXO|95uI7$uA15J$*erGt!aR3wr
zBr(Q+Ljm5RE20#qL-Y{$c9~YawYcxuzajPDpIp-zH_E7<aG51{7jR!L<K|rUmvL+U
E4btY(;Q#;t

diff --git a/mutate_token_sub.py b/mutate_token_sub.py
index 4856fbc..61afd5a 100644
--- a/mutate_token_sub.py
+++ b/mutate_token_sub.py
@@ -39,6 +39,212 @@ def find_nth(haystack, needle, n):
         n -= 1
     return start
 
+def subTokMutS(raw_tokens, all_tokens, raw_text):
+	new_text = raw_text
+	with open('vocabulary_mutate.json') as data_file:    
+    		data = json.load(data_file)
+		#pprint(data)
+		#print "HI"
+
+	out_tokens_loc = []
+	raw_tokens_pass = []
+	actual_token_len = []
+	orig = []
+	for token in all_tokens:
+		token_use = token		
+		#orig.append(token_use)
+		actual_token_len.append(token_use)
+
+	for token in raw_tokens:
+		token_use = token		
+		orig.append(token_use)
+	
+		raw_tokens_pass.append(token_use)
+
+	num_lines = len(actual_token_len)
+	num_encode = len(orig)	
+	if (num_lines % 10 == 0):
+		numTokensNeeded = int((num_lines / 10))
+	else:
+		numTokensNeeded = int((num_lines / 10))
+	insToks = []
+	fixToks = []
+	chosens = []
+
+	#print numTokensNeeded
+	#print "import num"
+
+	inds = []
+	for i in actual_token_len:
+		if i.type != 'COMMENT':
+			if i.type != 'INDENT':
+				if i.type != 'DEDENT':
+					if i.type != 'NEWLINE':
+						if i.type != 'NL':			
+							if i.type != 'ENDMARKER':
+								inds.append(actual_token_len.index(i))	
+
+	
+	allInds = []
+	for nah in range(numTokensNeeded+1):
+		temp = []
+		#print nah
+		for nahHoi in range(len(inds)):
+			if nah != 0:
+				flag = nah * 10
+				pastFlag = (nah-1)*10
+				#print "inds"
+				#print inds[nahHoi]
+				#print "indsSSS"
+				if pastFlag < inds[nahHoi] <= flag:	
+					temp.append(inds[nahHoi])
+		if len(temp) != 0:
+			allInds.append(temp)
+
+	
+	curr = 0
+	new_text = ''
+	haha = -1
+	radOut = 0
+	while radOut < len(allInds):
+
+		if radOut == (numTokensNeeded-1):
+			param_start = haha
+			param_end = num_lines-1
+		else:
+			param_start = radOut * 10
+			param_end = param_start + 9
+			haha = param_end
+
+		toChooseArr = allInds[radOut]
+		
+		chosenLineIndTemp = randint(0, len(toChooseArr)-1) #num_lines-1
+
+		chosenLineInd = toChooseArr[chosenLineIndTemp]
+		#print "ok"
+		#print chosenLineInd
+		chosens.append(chosenLineInd)
+		#print radOut
+
+		source_code = raw_text
+
+		send = actual_token_len[chosenLineInd]
+		
+		fixToks.append(send)
+
+		chosenInd = randint(0,84)
+		chosenToken = data["indexes_m"][chosenInd]
+
+		global new_token
+		new_token = []
+		try:
+			toksG = tokenize.tokenize(StringIO.StringIO(chosenToken).readline, handle_token)
+		except tokenize.TokenError:
+			pass	
+		
+		insEdTok = new_token[0]
+		insTok = insEdTok
+		insToks.append(insTok)
+
+		indexToRemove = source_code.index(actual_token_len[chosenLineInd].line)
+
+		temp = source_code[indexToRemove:indexToRemove+len(actual_token_len[chosenLineInd].line)+1]
+
+		change = temp.strip()
+	
+		check = change.find(raw_tokens_pass[chosenLineInd][1])
+
+		shotInd = temp.index(raw_tokens_pass[chosenLineInd][1])
+
+		change = temp.strip()
+		check = temp.index(change)
+		#print "WHAT"
+		#print change
+	
+
+		#print "TEMP"
+		#print temp
+
+		#print shotInd
+	
+		actual_target_ind = indexToRemove + shotInd
+	
+		#print raw_tokens_pass[chosenLineInd][1]
+	
+		#print len(raw_tokens_pass[chosenLineInd][1])
+		#print len(change)
+	
+		if check == 0 and len(raw_tokens_pass[chosenLineInd][1]) == len(change):
+			before = source_code[:indexToRemove]
+		else:
+			before = source_code[:actual_target_ind]
+		#print "B"
+		#print before
+		
+	
+		after = source_code[actual_target_ind+len(raw_tokens_pass[chosenLineInd][1]):]
+		#print "A"
+		#print after	
+		#print chosenToken.encode()
+		if check == 0:
+			#print "GOT EM"
+			if len(after) > 0:
+				if after[0] == ' ':
+					new_text = before + chosenToken.encode() + after
+				else:
+					new_text = before + chosenToken.encode() + after
+			else:
+				new_text = before + chosenToken.encode() + after
+		else:	
+		
+			if chosenInd == data["indexes_m"].index('\n'): 
+				#print "shiz"
+				if after[0] == ' ':
+					space = ' ' * (check-1)
+				else:
+					space = ' ' * (check)
+				new_text = before + chosenToken.encode() + space + after
+			else:	
+				#print "WAS HERE"
+				new_text = before + chosenToken.encode() + after
+
+
+		#print actual_target_ind
+
+		#print '-------------------------------'
+		#print new_text
+		toTest = checkPyPySyntax(new_text)
+		if toTest == None:
+			#print radOut
+			#if radOut != 0:
+			#	radOut = radOut-1
+			#else:
+			#	radOut = 0
+			#print radOut	
+			curr = curr + 1
+			if curr > 10:
+				radOut = radOut + 1
+			else:
+				radOut = radOut
+				fixToks.remove(send)
+				chosens.remove(chosenLineInd)
+				insToks.remove(insTok)
+			#print "test_t"
+		else:
+			curr = 0
+			radOut = radOut + 1
+	
+
+	return new_text, YES_TOKEN, SUBSTITUTION, chosens, fixToks, insToks
+	
+	#print "-----------FINISHED-------------------"
+	#print chosenLineInd+1
+	#print out_tokens_loc
+	#print len(raw_tokens_pass)
+	#print len(out_tokens_loc)
+	#print lenD
+
+
 def subTokMut(raw_tokens, raw_text):
 
 	with open('vocabulary_mutate.json') as data_file:    
diff --git a/mutate_token_sub.pyc b/mutate_token_sub.pyc
index 2af272838b9b1d6ca3a3affb17d34580ba66e52f..995ba760cbb7c9a1c2259c0bb6f0713467fed907 100644
GIT binary patch
delta 2907
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

delta 384
zcmdmExJp)<`7<xqg7o~zWCkc;0@4mZT)cOp^j=m*hF}fejnC#YZ$8E^#L8E~36#mq
zOG&LrEsoEfd{@MhuY?gOq)-eZxilmun{mreZs4{x;sWx6*nmU{E08Ek%u7!#0dZ3+
zN>cMuf|x<l9589HiIWd<D^GsUEpM(45(eonN-U2r$<I#BD=q;k1#^M=!H!5tEJ=({
z%gjkFVF5~kc#|LVn#r>RIhlFIA^F+CCHycwU?buS5{ru`C-R6)p2uS;$P1K9&d4uL
z&GX63OZCi4nanEYJ^383m=s6`?4FSPpw!&_GKd8wsksG{P5FFzKn}@E1-c99kjagF
zqLU|zB{OPG{wg+?O#~<vq&#_scodr|h^agIhq#V_9*8LhB4j~C$Ye{2SVo1((<PJv
D?kr*=

diff --git a/py_mutations_hub.py b/py_mutations_hub.py
index b7a979e..6f1da00 100644
--- a/py_mutations_hub.py
+++ b/py_mutations_hub.py
@@ -15,7 +15,7 @@
 from mutate_deletion import deleteMut
 from mutate_token_insert import insertTokMutS
 from mutate_token_delete import deleteTokMutS
-from mutate_token_sub import subTokMut
+from mutate_token_sub import subTokMutS
 import sys
 import cPickle
 
@@ -558,11 +558,11 @@ def perform(curr):
 			global indexed_tokens
 			indexed_tokens = []
 			#print type(raw_tokens)
-			
-			new_s_text, YES_TOKEN, SUBSTITUTION, out_tokens_loc_s, sendS, insTokS = subTokMut(raw_tokens, source_code)
+			passBall = allGood[:]
+			new_s_text, YES_TOKEN, SUBSTITUTION, chosensS, fixToksS, insToksS = subTokMutS(raw_tokens, passBall, source_code)
 
 			while isinstance(new_s_text, int):
-				new_s_text, YES_TOKEN, SUBSTITUTION, out_tokens_loc_s, sendS, insTokS = subTokMut(YES_TOKEN, SUBSTITUTION)
+				new_s_text, YES_TOKEN, SUBSTITUTION, chosensS, fixToksS, insToksS = subTokMutS(YES_TOKEN, SUBSTITUTION)
 				if isinstance(new_s_text, str):
 					break
 			
@@ -572,31 +572,53 @@ def perform(curr):
 
 			new_tokens_sub = allGood[:]
 
-			vocab_entry = open_closed_tokens(sendS)
-			sendS.value = vocab_entry
-			
-			bruhInd = -1
-			iterInd = 0
-			for a in allGood:
-				if a == sendS:
-					bruhInd = iterInd
-				iterInd = iterInd + 1
-			#print bruhInd
-			#print len(new_tokens_del)
-			del new_tokens_sub[bruhInd]	
+			temp = insToksS[:]
+			for insTok in temp:
+				if insTok.type == "NL":
+					insToks[insToksS.index(insTok)].type = "NEWLINE"
+
 			
+			tempFix = fixToksS[:]
+			for send in tempFix:
+				vocab_entry = open_closed_tokens(send)
+				fixToksS[fixToksS.index(send)].value = vocab_entry
+
+			removeInds = []
+			for wow in range(len(chosensS)):
+				bruhInd = -1
+				iterInd = 0
+				send = fixToksS[wow]	
+				#print send.value
+				for a in allGood:
+					if a == send:
+						bruhInd = iterInd
+					iterInd = iterInd + 1
+				#print bruhInd
+				#print "CHECK"
+				#print len(new_tokens_del)
+				removeInds.append(bruhInd)
+				#del new_tokens_del[bruhInd]	
+				#print len(new_tokens_del)
+				#print "DEL ROR"
+		
 			# SUB INSERT
+			#print len(removeInds)
+			#print len(insToksS)
+			comeIter = len(insToksS)-1
+			for r in reversed(removeInds):
+				del new_tokens_sub[r]
+				#print insToksS[comeIter].value
+				new_tokens_sub.insert(r, insToksS[comeIter])
+				comeIter -= 1
+			#for x in new_tokens_sub:
+				#print x.value
+			#print len(new_tokens_del)
 		
-			if insTokS.type == "NL":
-				insTokS.type = "NEWLINE"
-			if insTokS.type == "ENDMARKER":
-				insTokS.type = "INDENT"
 
 			#print insTokS.type
 			#print insTokS.value
 			#print "LUNCH"
 
-			new_tokens_sub.insert(bruhInd, insTokS)
 
 			one_hot_bad_sub = vocabularize_tokens(new_tokens_sub, True)
 
@@ -611,12 +633,13 @@ def perform(curr):
 			#print "sub"
 			#print sendS.type
 			#print sendS.value
-			oneH_sub_switch = set_from_json_nonarr(sendS, True)
+			#oneH_sub_switch = set_from_json_nonarr(sendS, True)
 			#print oneH_sub_switch
 			#print "rad"
 			for x in range(iterNum):
 				#if x <= trueErrorInd <= (x+trueErrorInd):
-				if x <= trueErrorInd <= x+(WINDOW_SIZE-1):
+				#if x <= trueErrorInd <= x+(WINDOW_SIZE-1):
+				if True:
 					# DIFF - ACTUAL ERROR
 					#print x
 					toAdd = []
@@ -630,8 +653,9 @@ def perform(curr):
 					toAdd[4] = 1
 					toAdd[5] = 0
 					toAdd[6] = 0
-					toAdd[7+trueErrorInd-x] = 1
-					toAdd[17+oneH_sub_switch] = 1
+
+					toAdd[7] = 1
+					toAdd[17] = 1
 					one_hot_bad_sub_out.append(toAdd)
 				else:
 					toAdd = []
diff --git a/toCheck.py b/toCheck.py
new file mode 100644
index 0000000..359501b
--- /dev/null
+++ b/toCheck.py
@@ -0,0 +1,570 @@
+# -*- coding: utf-8 -*-
+# Licensed to the StackStorm, Inc ('StackStorm') under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You 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.
+
+import mock
+
+from st2common.exceptions.param import ParamException
+from st2common.models.system.common import ResourceReference
+from st2common.models.db.liveaction import LiveActionDB
+from st2common.models.db.keyvalue import KeyValuePairDB
+from st2common.models.utils import action_param_utils
+from st2common.persistence.keyvalue import KeyValuePair
+from st2common.transport.publishers import PoolPublisher
+from st2common.util import date as date_utils
+from st2common.util import param as param_utils
+from st2tests import DbTestCase
+from st2tests.fixturesloader import FixturesLoader
+
+
+FIXTURES_PACK = 'generic'
+
+TEST_MODELS = {
+    'actions': ['action_4_action_context_param.yaml', 'action_system_default.yaml'],
+    'runners': ['testrunner1.yaml']
+}
+
+FIXTURES = FixturesLoader().load_models(fixtures_pack=FIXTURES_PACK,
+                                        fixtures_dict=TEST_MODELS)
+
+
+@mock.patch.object(PoolPublisher, 'publish', mock.MagicMock())
+class ParamsUtilsTest(DbTestCase):
+    action_db = FIXTURES['actions']['action_4_action_context_param.yaml']
+    action_system_default_db = FIXTURES['actions']['action_system_default.yaml']
+    runnertype_db = FIXTURES['runners']['testrunner1.yaml']
+
+    def test_get_finalized_params(self):
+        params = {
+            'actionstr': 'foo',
+            'some_key_that_aint_exist_in_action_or_runner': 'bar',
+            'runnerint': 555,
+            'runnerimmutable': 'failed_override',
+            'actionimmutable': 'failed_override'
+        }
+        liveaction_db = self._get_liveaction_model(params)
+
+        runner_params, action_params = param_utils.get_finalized_params(
+            ParamsUtilsTest.runnertype_db.runner_parameters, except 
+            ParamsUtilsTest.action_db.parameters,
+            liveaction_db.parameters,
+            liveaction_db.context)
+
+        # Asserts for runner params.
+        # Assert that default values for runner params are resolved.
+        self.assertEqual(runner_params.get('runnerstr'), 'defaultfoo')
+        # Assert that a runner param from action exec is picked up.
+        self.assertEqual(runner_params.get('runnerint'), 555)
+        # Assert that a runner param can be overridden by action param default.
+        self.assertEqual(runner_params.get('runnerdummy'), 'actiondummy')
+        # Assert that a runner param default can be overridden by 'falsey' action param default,
+        # (timeout: 0 case).
+        self.assertEqual(runner_params.get('runnerdefaultint'), 0)
+        # Assert that an immutable param cannot be overridden by action param or execution param.
+        self.assertEqual(runner_params.get('runnerimmutable'), 'runnerimmutable')
+
+        # Asserts for action params.
+        self.assertEqual(action_params.get('actionstr'), 'foo')
+        # Assert that a param that is provided in action exec that isn't in action or runner params
+        # isn't in resolved params.
+        self.assertEqual(action_params.get('some_key_that_aint_exist_in_action_or_runner'), None)
+        # Assert that an immutable param cannot be overridden by execution param.
+        self.assertEqual(action_params.get('actionimmutable'), 'actionimmutable')
+        # Assert that an action context param is set correctly.
+        self.assertEqual(action_params.get('action_api_user'), 'noob')
+        # Assert that none of runner params are present in action_params.
+        for k in action_params:
+            self.assertTrue(k not in runner_params, 'Param ' + k + ' is a runner param.')
+
+    def test_get_finalized_params_system_values(self):
+        KeyValuePair.add_or_update(KeyValuePairDB(name='actionstr', value='foo'))
+        KeyValuePair.add_or_update(KeyValuePairDB(name='actionnumber', value='1.0'))
+        params = {
+            'runnerint': 555
+        }
+        liveaction_db = self._get_liveaction_model(params)
+
+        runner_params, action_params = param_utils.get_finalized_params(
+            ParamsUtilsTest.runnertype_db.runner_parameters,
+            ParamsUtilsTest.action_system_default_db.parameters,
+            liveaction_db.parameters,
+            liveaction_db.context)
+
+        # Asserts for runner params.
+        # Assert that default values for runner params are resolved.
+        self.assertEqual(runner_params.get('runnerstr'), 'defaultfoo')
+        # Assert that a runner param from action exec is picked up.
+        self.assertEqual(runner_params.get('runnerint'), 555)
+        # Assert that an immutable param cannot be overridden by action param or execution param.
+        self.assertEqual(runner_params.get('runnerimmutable'), 'runnerimmutable')
+
+        # Asserts for action params.
+        self.assertEqual(action_params.get('actionstr'), 'foo')
+        self.assertEqual(action_params.get('actionnumber'), 1.0)
+
+    def test_get_finalized_params_action_immutable(self):
+        params = {
+            'actionstr': 'foo',
+            'some_key_that_aint_exist_in_action_or_runner': 'bar',
+            'runnerint': 555,
+            'actionimmutable': 'failed_override'
+        }
+        liveaction_db = self._get_liveaction_model(params)
+        action_context = {'api_user': None}
+
+        runner_params, action_params = param_utils.get_finalized_params(
+            ParamsUtilsTest.runnertype_db.runner_parameters,
+            ParamsUtilsTest.action_db.parameters,
+            liveaction_db.parameters,
+            action_context)
+
+        # Asserts for runner params.
+        # Assert that default values for runner params are resolved.
+        self.assertEqual(runner_params.get('runnerstr'), 'defaultfoo')
+        # Assert that a runner param from action exec is picked up.
+        self.assertEqual(runner_params.get('runnerint'), 555)
+        # Assert that a runner param can be overridden by action param default.
+        self.assertEqual(runner_params.get('runnerdummy'), 'actiondummy')
+
+        # Asserts for action params.
+        self.assertEqual(action_params.get('actionstr'), 'foo')
+        # Assert that a param that is provided in action exec that isn't in action or runner params
+        # isn't in resolved params.
+        self.assertEqual(action_params.get('some_key_that_aint_exist_in_action_or_runner'), None)
+
+    def test_get_finalized_params_empty(self):
+        params = {}
+        runner_param_info = {}
+        action_param_info = {}
+        action_context = {}
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+        self.assertEqual(r_runner_params, params)
+        self.assertEqual(r_action_params, params)
+
+    def test_get_finalized_params_none(self):
+        params = {
+            'r1': None,
+            'a1': None
+        }
+        runner_param_info = {'r1': {}}
+        action_param_info = {'a1': {}}
+        action_context = {'api_user': None}
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+        self.assertEqual(r_runner_params, {'r1': None})
+        self.assertEqual(r_action_params, {'a1': None})
+
+    def test_get_finalized_params_no_cast(self):
+        params = {
+            'r1': '{{r2}}',
+            'r2': 1,
+            'a1': True,
+            'a2': '{{r1}} {{a1}}',
+            'a3': '{{action_context.api_user}}'
+        }
+        runner_param_info = {'r1': {}, 'r2': {}}
+        action_param_info = {'a1': {}, 'a2': {}, 'a3': {}}
+        action_context = {'api_user': 'noob'}
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+        self.assertEqual(r_runner_params, {'r1': u'1', 'r2': 1})
+        self.assertEqual(r_action_params, {'a1': True, 'a2': u'1 True', 'a3': 'noob'})
+
+    def test_get_finalized_params_with_cast(self):
+        # Note : In this test runner_params.r1 has a string value. However per runner_param_info the
+        # type is an integer. The expected type is considered and cast is performed accordingly.
+        params = {
+            'r1': '{{r2}}',
+            'r2': 1,
+            'a1': True,
+            'a2': '{{a1}}',
+            'a3': '{{action_context.api_user}}'
+        }
+        runner_param_info = {'r1': {'type': 'integer'}, 'r2': {'type': 'integer'}}
+        action_param_info = {'a1': {'type': 'boolean'}, 'a2': {'type': 'boolean'}, 'a3': {}}
+        action_context = {'api_user': 'noob'}
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+        self.assertEqual(r_runner_params, {'r1': 1, 'r2': 1})
+        self.assertEqual(r_action_params, {'a1': True, 'a2': True, 'a3': 'noob'})
+
+    def test_get_finalized_params_with_cast_overriden(self):
+        params = {
+            'r1': '{{r2}}',
+            'r2': 1,
+            'a1': '{{r1}}',
+            'a2': '{{r1}}',
+            'a3': '{{r1}}'
+        }
+        runner_param_info = {'r1': {'type': 'integer'}, 'r2': {'type': 'integer'}}
+        action_param_info = {'a1': {'type': 'boolean'}, 'a2': {'type': 'string'},
+                             'a3': {'type': 'integer'}, 'r1': {'type': 'string'}}
+        action_context = {'api_user': 'noob'}
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+        self.assertEqual(r_runner_params, {'r1': 1, 'r2': 1})
+        self.assertEqual(r_action_params, {'a1': 1, 'a2': u'1', 'a3': 1})
+
+    def test_get_finalized_params_cross_talk_no_cast(self):
+        params = {
+            'r1': '{{a1}}',
+            'r2': 1,
+            'a1': True,
+            'a2': '{{r1}} {{a1}}',
+            'a3': '{{action_context.api_user}}'
+        }
+        runner_param_info = {'r1': {}, 'r2': {}}
+        action_param_info = {'a1': {}, 'a2': {}, 'a3': {}}
+        action_context = {'api_user': 'noob'}
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+        self.assertEqual(r_runner_params, {'r1': u'True', 'r2': 1})
+        self.assertEqual(r_action_params, {'a1': True, 'a2': u'True True', 'a3': 'noob'})
+
+    def test_get_finalized_params_cross_talk_with_cast(self):
+        params = {
+            'r1': '{{a1}}',
+            'r2': 1,
+            'r3': 1,
+            'a1': True,
+            'a2': '{{r1}},{{a1}},{{a3}},{{r3}}',
+            'a3': '{{a1}}'
+        }
+        runner_param_info = {'r1': {'type': 'boolean'}, 'r2': {'type': 'integer'}, 'r3': {}}
+        action_param_info = {'a1': {'type': 'boolean'}, 'a2': {'type': 'array'}, 'a3': {}}
+        action_context = {}
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+        self.assertEqual(r_runner_params, {'r1': True, 'r2': 1, 'r3': 1})
+        self.assertEqual(r_action_params, {'a1': True, 'a2': (True, True, True, 1), 'a3': u'True'})
+
+    def test_get_finalized_params_order(self):
+        params = {
+            'r1': 'p1',
+            'r2': 'p2',
+            'r3': 'p3',
+            'a1': 'p4',
+            'a2': 'p5'
+        }
+        runner_param_info = {'r1': {}, 'r2': {'default': 'r2'}, 'r3': {'default': 'r3'}}
+        action_param_info = {'a1': {}, 'a2': {'default': 'a2'}, 'r3': {'default': 'a3'}}
+        action_context = {'api_user': 'noob'}
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+        self.assertEqual(r_runner_params, {'r1': u'p1', 'r2': u'p2', 'r3': u'p3'})
+        self.assertEqual(r_action_params, {'a1': u'p4', 'a2': u'p5'})
+
+        params = {}
+        runner_param_info = {'r1': {}, 'r2': {'default': 'r2'}, 'r3': {'default': 'r3'}}
+        action_param_info = {'a1': {}, 'a2': {'default': 'a2'}, 'r3': {'default': 'a3'}}
+        action_context = {'api_user': 'noob'}
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+        self.assertEqual(r_runner_params, {'r1': None, 'r2': u'r2', 'r3': u'a3'})
+        self.assertEqual(r_action_params, {'a1': None, 'a2': u'a2'})
+
+        params = {}
+        runner_param_info = {'r1': {}, 'r2': {'default': 'r2'}, 'r3': {}}
+        action_param_info = {'r1': {}, 'r2': {}, 'r3': {'default': 'a3'}}
+        action_context = {'api_user': 'noob'}
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+        self.assertEqual(r_runner_params, {'r1': None, 'r2': u'r2', 'r3': u'a3'})
+
+    def test_get_finalized_params_non_existent_template_key_in_action_context(self):
+        params = {
+            'r1': 'foo',
+            'r2': 2,
+            'a1': 'i love tests',
+            'a2': '{{action_context.lorem_ipsum}}'
+        }
+        runner_param_info = {'r1': {'type': 'string'}, 'r2': {'type': 'integer'}}
+        action_param_info = {'a1': {'type': 'string'}, 'a2': {'type': 'string'}}
+        action_context = {'api_user': 'noob', 'source_channel': 'reddit'}
+        try:
+            r_runner_params, r_action_params = param_utils.get_finalized_params(
+                runner_param_info, action_param_info, params, action_context)
+            self.fail('This should have thrown because we are trying to deref a key in ' +
+                      'action context that ain\'t exist.')
+        except ParamException as e:
+            error_msg = 'Failed to render parameter "a2": \'dict object\' ' + \
+                        'has no attribute \'lorem_ipsum\''
+            self.assertTrue(error_msg in e.message)
+            pass
+
+    def test_unicode_value_casting(self):
+        rendered = {'a1': 'unicode1 ٩(̾●̮̮̃̾•̃̾)۶ unicode2'}
+        parameter_schemas = {'a1': {'type': 'string'}}
+
+        result = param_utils._cast_params(rendered=rendered,
+                                          parameter_schemas=parameter_schemas)
+        expected = {
+            'a1': (u'unicode1 \xd9\xa9(\xcc\xbe\xe2\x97\x8f\xcc\xae\xcc\xae\xcc'
+                   u'\x83\xcc\xbe\xe2\x80\xa2\xcc\x83\xcc\xbe)\xdb\xb6 unicode2')
+        }
+        self.assertEqual(result, expected)
+
+    def test_get_finalized_params_with_casting_unicode_values(self):
+        params = {'a1': 'unicode1 ٩(̾●̮̮̃̾•̃̾)۶ unicode2'}
+
+        runner_param_info = {}
+        action_param_info = {'a1': {'type': 'string'}}
+
+        action_context = {}
+
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+
+        expected_action_params = {
+            'a1': (u'unicode1 \xd9\xa9(\xcc\xbe\xe2\x97\x8f\xcc\xae\xcc\xae\xcc'
+                   u'\x83\xcc\xbe\xe2\x80\xa2\xcc\x83\xcc\xbe)\xdb\xb6 unicode2')
+        }
+        self.assertEqual(r_runner_params, {})
+        self.assertEqual(r_action_params, expected_action_params)
+
+    def test_get_finalized_params_with_dict(self):
+        # Note : In this test runner_params.r1 has a string value. However per runner_param_info the
+        # type is an integer. The expected type is considered and cast is performed accordingly.
+        params = {
+            'r1': '{{r2}}',
+            'r2': {'r2.1': 1},
+            'a1': True,
+            'a2': '{{a1}}',
+            'a3': {
+                'test': '{{a1}}',
+                'test1': '{{a4}}',
+                'test2': '{{a5}}',
+            },
+            'a4': 3,
+            'a5': ['1', '{{a1}}']
+        }
+        runner_param_info = {'r1': {'type': 'object'}, 'r2': {'type': 'object'}}
+        action_param_info = {
+            'a1': {
+                'type': 'boolean',
+            },
+            'a2': {
+                'type': 'boolean',
+            },
+            'a3': {
+                'type': 'object',
+            },
+            'a4': {
+                'type': 'integer',
+            },
+            'a5': {
+                'type': 'array',
+            },
+        }
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, {})
+        self.assertEqual(
+            r_runner_params, {'r1': {'r2.1': 1}, 'r2': {'r2.1': 1}})
+        self.assertEqual(
+            r_action_params,
+            {
+                'a1': True,
+                'a2': True,
+                'a3': {
+                    'test': True,
+                    'test1': 3,
+                    'test2': [
+                        '1',
+                        True
+                    ],
+                },
+                'a4': 3,
+                'a5': [
+                    '1',
+                    True
+                ],
+            }
+        )
+
+    def test_get_finalized_params_with_list(self):
+        # Note : In this test runner_params.r1 has a string value. However per runner_param_info the
+        # type is an integer. The expected type is considered and cast is performed accordingly.
+        self.maxDiff = None
+        params = {
+            'r1': '{{r2}}',
+            'r2': ['1', '2'],
+            'a1': True,
+            'a2': 'Test',
+            'a3': 'Test2',
+            'a4': '{{a1}}',
+            'a5': ['{{a2}}', '{{a3}}'],
+            'a6': [
+                ['{{r2}}', '{{a2}}'],
+                ['{{a3}}', '{{a1}}'],
+                [
+                    '{{a7}}',
+                    'This should be rendered as a string {{a1}}',
+                    '{{a1}} This, too, should be rendered as a string {{a1}}',
+                ]
+            ],
+            'a7': 5,
+        }
+        runner_param_info = {'r1': {'type': 'array'}, 'r2': {'type': 'array'}}
+        action_param_info = {
+            'a1': {'type': 'boolean'},
+            'a2': {'type': 'string'},
+            'a3': {'type': 'string'},
+            'a4': {'type': 'boolean'},
+            'a5': {'type': 'array'},
+            'a6': {'type': 'array'},
+            'a7': {'type': 'integer'},
+        }
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, {})
+        self.assertEqual(r_runner_params, {'r1': ['1', '2'], 'r2': ['1', '2']})
+        self.assertEqual(
+            r_action_params,
+            {
+                'a1': True,
+                'a2': 'Test',
+                'a3': 'Test2',
+                'a4': True,
+                'a5': ['Test', 'Test2'],
+                'a6': [
+                    [['1', '2'], 'Test'],
+                    ['Test2', True],
+                    [
+                        5,
+                        u'This should be rendered as a string True',
+                        u'True This, too, should be rendered as a string True'
+                    ]
+                ],
+                'a7': 5,
+            }
+        )
+
+    def test_get_finalized_params_with_cyclic_dependency(self):
+        params = {'r1': '{{r2}}', 'r2': '{{r1}}'}
+        runner_param_info = {'r1': {}, 'r2': {}}
+        action_param_info = {}
+        test_pass = True
+        try:
+            param_utils.get_finalized_params(runner_param_info, action_param_info, params, {})
+            test_pass = False
+        except ParamException as e:
+            test_pass = e.message.find('Cyclic') == 0
+        self.assertTrue(test_pass)
+
+    def test_get_finalized_params_with_missing_dependency(self):
+        params = {'r1': '{{r3}}', 'r2': '{{r3}}'}
+        runner_param_info = {'r1': {}, 'r2': {}}
+        action_param_info = {}
+        test_pass = True
+        try:
+            param_utils.get_finalized_params(runner_param_info, action_param_info, params, {})
+            test_pass = False
+        except ParamException as e:
+            test_pass = e.message.find('Dependecy') == 0
+        self.assertTrue(test_pass)
+
+        params = {}
+        runner_param_info = {'r1': {'default': '{{r3}}'}, 'r2': {'default': '{{r3}}'}}
+        action_param_info = {}
+        test_pass = True
+        try:
+            param_utils.get_finalized_params(runner_param_info, action_param_info, params, {})
+            test_pass = False
+        except ParamException as e:
+            test_pass = e.message.find('Dependecy') == 0
+        self.assertTrue(test_pass)
+
+    def test_get_finalized_params_no_double_rendering(self):
+        params = {
+            'r1': '{{ action_context.h1 }}{{ action_context.h2 }}'
+        }
+        runner_param_info = {'r1': {}}
+        action_param_info = {}
+        action_context = {
+            'h1': '{',
+            'h2': '{ missing }}'
+        }
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+        self.assertEqual(r_runner_params, {'r1': '{{ missing }}'})
+        self.assertEqual(r_action_params, {})
+
+    def test_get_finalized_params_jinja_filters(self):
+        params = {'cmd': 'echo {{"1.6.0" | version_bump_minor}}'}
+        runner_param_info = {'r1': {}}
+        action_param_info = {'cmd': {}}
+        action_context = {}
+
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+
+        self.assertEqual(r_action_params['cmd'], "echo 1.7.0")
+
+    def test_get_finalized_params_param_rendering_failure(self):
+        params = {'cmd': '{{a2.foo}}', 'a2': 'test'}
+        action_param_info = {'cmd': {}, 'a2': {}}
+
+        expected_msg = 'Failed to render parameter "cmd": .*'
+        self.assertRaisesRegexp(ParamException,
+                                expected_msg,
+                                param_utils.get_finalized_params,
+                                runnertype_parameter_info={},
+                                action_parameter_info=action_param_info,
+                                liveaction_parameters=params,
+                                action_context={})
+
+    def test_get_finalized_param_object_contains_template_notation_in_the_value(self):
+        runner_param_info = {'r1': {}}
+        action_param_info = {
+            'params': {
+                'type': 'object',
+                'default': {
+                    'host': '{{host}}',
+                    'port': '{{port}}',
+                    'path': '/bar'}
+            }
+        }
+        params = {
+            'host': 'lolcathost',
+            'port': 5555
+        }
+        action_context = {}
+
+        r_runner_params, r_action_params = param_utils.get_finalized_params(
+            runner_param_info, action_param_info, params, action_context)
+
+        expected_params = {
+            'host': 'lolcathost',
+            'port': 5555,
+            'path': '/bar'
+        }
+        self.assertEqual(r_action_params['params'], expected_params)
+
+    def test_cast_param_referenced_action_doesnt_exist(self):
+        # Make sure the function throws if the action doesnt exist
+        expected_msg = 'Action with ref "foo.doesntexist" doesn\'t exist'
+        self.assertRaisesRegexp(ValueError, expected_msg, action_param_utils.cast_params,
+                                action_ref='foo.doesntexist', params={})
+
+    def _get_liveaction_model(self, params):
+        status = 'initializing'
+        start_timestamp = date_utils.get_datetime_utc_now()
+        action_ref = ResourceReference(name=ParamsUtilsTest.action_db.name,
+                                       pack=ParamsUtilsTest.action_db.pack).ref
+        liveaction_db = LiveActionDB(status=status, start_timestamp=start_timestamp,
+                                     action=action_ref, parameters=params)
+        liveaction_db.context = {'source_channel': 'awesome', 'api_user': 'noob'}
+
+        return liveaction_db