Browse code

remove build-related type fields from internal api

BuildSpec.Source.Type
BuildSpec.Strategy.Type
BuildRequest.Revision.Type
GenericWebHookEvent.Type

Code should instead check for non-nil values to determine the type.
This allows for multiple inputs to be used simultaneously (eg
more than one source input)

Ben Parees authored on 2015/12/04 08:34:25
Showing 51 changed files
... ...
@@ -944,7 +944,6 @@ func deepCopy_api_BuildRequest(in buildapi.BuildRequest, out *buildapi.BuildRequ
944 944
 }
945 945
 
946 946
 func deepCopy_api_BuildSource(in buildapi.BuildSource, out *buildapi.BuildSource, c *conversion.Cloner) error {
947
-	out.Type = in.Type
948 947
 	if in.Binary != nil {
949 948
 		out.Binary = new(buildapi.BinaryBuildSource)
950 949
 		if err := deepCopy_api_BinaryBuildSource(*in.Binary, out.Binary, c); err != nil {
... ...
@@ -1051,7 +1050,6 @@ func deepCopy_api_BuildStatus(in buildapi.BuildStatus, out *buildapi.BuildStatus
1051 1051
 }
1052 1052
 
1053 1053
 func deepCopy_api_BuildStrategy(in buildapi.BuildStrategy, out *buildapi.BuildStrategy, c *conversion.Cloner) error {
1054
-	out.Type = in.Type
1055 1054
 	if in.DockerStrategy != nil {
1056 1055
 		out.DockerStrategy = new(buildapi.DockerBuildStrategy)
1057 1056
 		if err := deepCopy_api_DockerBuildStrategy(*in.DockerStrategy, out.DockerStrategy, c); err != nil {
... ...
@@ -1270,7 +1268,6 @@ func deepCopy_api_SourceControlUser(in buildapi.SourceControlUser, out *buildapi
1270 1270
 }
1271 1271
 
1272 1272
 func deepCopy_api_SourceRevision(in buildapi.SourceRevision, out *buildapi.SourceRevision, c *conversion.Cloner) error {
1273
-	out.Type = in.Type
1274 1273
 	if in.Git != nil {
1275 1274
 		out.Git = new(buildapi.GitSourceRevision)
1276 1275
 		if err := deepCopy_api_GitSourceRevision(*in.Git, out.Git, c); err != nil {
... ...
@@ -204,7 +204,6 @@ func TestGraph(t *testing.T) {
204 204
 			},
205 205
 			BuildSpec: buildapi.BuildSpec{
206 206
 				Strategy: buildapi.BuildStrategy{
207
-					Type: buildapi.SourceBuildStrategyType,
208 207
 					SourceStrategy: &buildapi.SourceBuildStrategy{
209 208
 						From: kapi.ObjectReference{Kind: "ImageStreamTag", Name: "test:base-image"},
210 209
 					},
... ...
@@ -1339,8 +1339,7 @@ func autoconvert_api_BuildRequest_To_v1_BuildRequest(in *buildapi.BuildRequest,
1339 1339
 		return err
1340 1340
 	}
1341 1341
 	if in.Revision != nil {
1342
-		out.Revision = new(apiv1.SourceRevision)
1343
-		if err := convert_api_SourceRevision_To_v1_SourceRevision(in.Revision, out.Revision, s); err != nil {
1342
+		if err := s.Convert(&in.Revision, &out.Revision, 0); err != nil {
1344 1343
 			return err
1345 1344
 		}
1346 1345
 	} else {
... ...
@@ -1397,7 +1396,6 @@ func autoconvert_api_BuildSource_To_v1_BuildSource(in *buildapi.BuildSource, out
1397 1397
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
1398 1398
 		defaulting.(func(*buildapi.BuildSource))(in)
1399 1399
 	}
1400
-	out.Type = apiv1.BuildSourceType(in.Type)
1401 1400
 	if in.Binary != nil {
1402 1401
 		out.Binary = new(apiv1.BinaryBuildSource)
1403 1402
 		if err := convert_api_BinaryBuildSource_To_v1_BinaryBuildSource(in.Binary, out.Binary, s); err != nil {
... ...
@@ -1432,27 +1430,22 @@ func autoconvert_api_BuildSource_To_v1_BuildSource(in *buildapi.BuildSource, out
1432 1432
 	return nil
1433 1433
 }
1434 1434
 
1435
-func convert_api_BuildSource_To_v1_BuildSource(in *buildapi.BuildSource, out *apiv1.BuildSource, s conversion.Scope) error {
1436
-	return autoconvert_api_BuildSource_To_v1_BuildSource(in, out, s)
1437
-}
1438
-
1439 1435
 func autoconvert_api_BuildSpec_To_v1_BuildSpec(in *buildapi.BuildSpec, out *apiv1.BuildSpec, s conversion.Scope) error {
1440 1436
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
1441 1437
 		defaulting.(func(*buildapi.BuildSpec))(in)
1442 1438
 	}
1443 1439
 	out.ServiceAccount = in.ServiceAccount
1444
-	if err := convert_api_BuildSource_To_v1_BuildSource(&in.Source, &out.Source, s); err != nil {
1440
+	if err := s.Convert(&in.Source, &out.Source, 0); err != nil {
1445 1441
 		return err
1446 1442
 	}
1447 1443
 	if in.Revision != nil {
1448
-		out.Revision = new(apiv1.SourceRevision)
1449
-		if err := convert_api_SourceRevision_To_v1_SourceRevision(in.Revision, out.Revision, s); err != nil {
1444
+		if err := s.Convert(&in.Revision, &out.Revision, 0); err != nil {
1450 1445
 			return err
1451 1446
 		}
1452 1447
 	} else {
1453 1448
 		out.Revision = nil
1454 1449
 	}
1455
-	if err := convert_api_BuildStrategy_To_v1_BuildStrategy(&in.Strategy, &out.Strategy, s); err != nil {
1450
+	if err := s.Convert(&in.Strategy, &out.Strategy, 0); err != nil {
1456 1451
 		return err
1457 1452
 	}
1458 1453
 	if err := s.Convert(&in.Output, &out.Output, 0); err != nil {
... ...
@@ -1517,7 +1510,6 @@ func autoconvert_api_BuildStrategy_To_v1_BuildStrategy(in *buildapi.BuildStrateg
1517 1517
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
1518 1518
 		defaulting.(func(*buildapi.BuildStrategy))(in)
1519 1519
 	}
1520
-	out.Type = apiv1.BuildStrategyType(in.Type)
1521 1520
 	if in.DockerStrategy != nil {
1522 1521
 		if err := s.Convert(&in.DockerStrategy, &out.DockerStrategy, 0); err != nil {
1523 1522
 			return err
... ...
@@ -1542,10 +1534,6 @@ func autoconvert_api_BuildStrategy_To_v1_BuildStrategy(in *buildapi.BuildStrateg
1542 1542
 	return nil
1543 1543
 }
1544 1544
 
1545
-func convert_api_BuildStrategy_To_v1_BuildStrategy(in *buildapi.BuildStrategy, out *apiv1.BuildStrategy, s conversion.Scope) error {
1546
-	return autoconvert_api_BuildStrategy_To_v1_BuildStrategy(in, out, s)
1547
-}
1548
-
1549 1545
 func autoconvert_api_BuildTriggerPolicy_To_v1_BuildTriggerPolicy(in *buildapi.BuildTriggerPolicy, out *apiv1.BuildTriggerPolicy, s conversion.Scope) error {
1550 1546
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
1551 1547
 		defaulting.(func(*buildapi.BuildTriggerPolicy))(in)
... ...
@@ -1770,7 +1758,6 @@ func autoconvert_api_SourceRevision_To_v1_SourceRevision(in *buildapi.SourceRevi
1770 1770
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
1771 1771
 		defaulting.(func(*buildapi.SourceRevision))(in)
1772 1772
 	}
1773
-	out.Type = apiv1.BuildSourceType(in.Type)
1774 1773
 	if in.Git != nil {
1775 1774
 		out.Git = new(apiv1.GitSourceRevision)
1776 1775
 		if err := convert_api_GitSourceRevision_To_v1_GitSourceRevision(in.Git, out.Git, s); err != nil {
... ...
@@ -1782,10 +1769,6 @@ func autoconvert_api_SourceRevision_To_v1_SourceRevision(in *buildapi.SourceRevi
1782 1782
 	return nil
1783 1783
 }
1784 1784
 
1785
-func convert_api_SourceRevision_To_v1_SourceRevision(in *buildapi.SourceRevision, out *apiv1.SourceRevision, s conversion.Scope) error {
1786
-	return autoconvert_api_SourceRevision_To_v1_SourceRevision(in, out, s)
1787
-}
1788
-
1789 1785
 func autoconvert_api_WebHookTrigger_To_v1_WebHookTrigger(in *buildapi.WebHookTrigger, out *apiv1.WebHookTrigger, s conversion.Scope) error {
1790 1786
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
1791 1787
 		defaulting.(func(*buildapi.WebHookTrigger))(in)
... ...
@@ -2068,8 +2051,7 @@ func autoconvert_v1_BuildRequest_To_api_BuildRequest(in *apiv1.BuildRequest, out
2068 2068
 		return err
2069 2069
 	}
2070 2070
 	if in.Revision != nil {
2071
-		out.Revision = new(buildapi.SourceRevision)
2072
-		if err := convert_v1_SourceRevision_To_api_SourceRevision(in.Revision, out.Revision, s); err != nil {
2071
+		if err := s.Convert(&in.Revision, &out.Revision, 0); err != nil {
2073 2072
 			return err
2074 2073
 		}
2075 2074
 	} else {
... ...
@@ -2126,7 +2108,7 @@ func autoconvert_v1_BuildSource_To_api_BuildSource(in *apiv1.BuildSource, out *b
2126 2126
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
2127 2127
 		defaulting.(func(*apiv1.BuildSource))(in)
2128 2128
 	}
2129
-	out.Type = buildapi.BuildSourceType(in.Type)
2129
+	// in.Type has no peer in out
2130 2130
 	if in.Binary != nil {
2131 2131
 		out.Binary = new(buildapi.BinaryBuildSource)
2132 2132
 		if err := convert_v1_BinaryBuildSource_To_api_BinaryBuildSource(in.Binary, out.Binary, s); err != nil {
... ...
@@ -2161,27 +2143,22 @@ func autoconvert_v1_BuildSource_To_api_BuildSource(in *apiv1.BuildSource, out *b
2161 2161
 	return nil
2162 2162
 }
2163 2163
 
2164
-func convert_v1_BuildSource_To_api_BuildSource(in *apiv1.BuildSource, out *buildapi.BuildSource, s conversion.Scope) error {
2165
-	return autoconvert_v1_BuildSource_To_api_BuildSource(in, out, s)
2166
-}
2167
-
2168 2164
 func autoconvert_v1_BuildSpec_To_api_BuildSpec(in *apiv1.BuildSpec, out *buildapi.BuildSpec, s conversion.Scope) error {
2169 2165
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
2170 2166
 		defaulting.(func(*apiv1.BuildSpec))(in)
2171 2167
 	}
2172 2168
 	out.ServiceAccount = in.ServiceAccount
2173
-	if err := convert_v1_BuildSource_To_api_BuildSource(&in.Source, &out.Source, s); err != nil {
2169
+	if err := s.Convert(&in.Source, &out.Source, 0); err != nil {
2174 2170
 		return err
2175 2171
 	}
2176 2172
 	if in.Revision != nil {
2177
-		out.Revision = new(buildapi.SourceRevision)
2178
-		if err := convert_v1_SourceRevision_To_api_SourceRevision(in.Revision, out.Revision, s); err != nil {
2173
+		if err := s.Convert(&in.Revision, &out.Revision, 0); err != nil {
2179 2174
 			return err
2180 2175
 		}
2181 2176
 	} else {
2182 2177
 		out.Revision = nil
2183 2178
 	}
2184
-	if err := convert_v1_BuildStrategy_To_api_BuildStrategy(&in.Strategy, &out.Strategy, s); err != nil {
2179
+	if err := s.Convert(&in.Strategy, &out.Strategy, 0); err != nil {
2185 2180
 		return err
2186 2181
 	}
2187 2182
 	if err := s.Convert(&in.Output, &out.Output, 0); err != nil {
... ...
@@ -2246,7 +2223,7 @@ func autoconvert_v1_BuildStrategy_To_api_BuildStrategy(in *apiv1.BuildStrategy,
2246 2246
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
2247 2247
 		defaulting.(func(*apiv1.BuildStrategy))(in)
2248 2248
 	}
2249
-	out.Type = buildapi.BuildStrategyType(in.Type)
2249
+	// in.Type has no peer in out
2250 2250
 	if in.DockerStrategy != nil {
2251 2251
 		if err := s.Convert(&in.DockerStrategy, &out.DockerStrategy, 0); err != nil {
2252 2252
 			return err
... ...
@@ -2271,10 +2248,6 @@ func autoconvert_v1_BuildStrategy_To_api_BuildStrategy(in *apiv1.BuildStrategy,
2271 2271
 	return nil
2272 2272
 }
2273 2273
 
2274
-func convert_v1_BuildStrategy_To_api_BuildStrategy(in *apiv1.BuildStrategy, out *buildapi.BuildStrategy, s conversion.Scope) error {
2275
-	return autoconvert_v1_BuildStrategy_To_api_BuildStrategy(in, out, s)
2276
-}
2277
-
2278 2274
 func autoconvert_v1_BuildTriggerPolicy_To_api_BuildTriggerPolicy(in *apiv1.BuildTriggerPolicy, out *buildapi.BuildTriggerPolicy, s conversion.Scope) error {
2279 2275
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
2280 2276
 		defaulting.(func(*apiv1.BuildTriggerPolicy))(in)
... ...
@@ -2499,7 +2472,7 @@ func autoconvert_v1_SourceRevision_To_api_SourceRevision(in *apiv1.SourceRevisio
2499 2499
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
2500 2500
 		defaulting.(func(*apiv1.SourceRevision))(in)
2501 2501
 	}
2502
-	out.Type = buildapi.BuildSourceType(in.Type)
2502
+	// in.Type has no peer in out
2503 2503
 	if in.Git != nil {
2504 2504
 		out.Git = new(buildapi.GitSourceRevision)
2505 2505
 		if err := convert_v1_GitSourceRevision_To_api_GitSourceRevision(in.Git, out.Git, s); err != nil {
... ...
@@ -2511,10 +2484,6 @@ func autoconvert_v1_SourceRevision_To_api_SourceRevision(in *apiv1.SourceRevisio
2511 2511
 	return nil
2512 2512
 }
2513 2513
 
2514
-func convert_v1_SourceRevision_To_api_SourceRevision(in *apiv1.SourceRevision, out *buildapi.SourceRevision, s conversion.Scope) error {
2515
-	return autoconvert_v1_SourceRevision_To_api_SourceRevision(in, out, s)
2516
-}
2517
-
2518 2514
 func autoconvert_v1_WebHookTrigger_To_api_WebHookTrigger(in *apiv1.WebHookTrigger, out *buildapi.WebHookTrigger, s conversion.Scope) error {
2519 2515
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
2520 2516
 		defaulting.(func(*apiv1.WebHookTrigger))(in)
... ...
@@ -1348,8 +1348,7 @@ func autoconvert_api_BuildRequest_To_v1beta3_BuildRequest(in *buildapi.BuildRequ
1348 1348
 		return err
1349 1349
 	}
1350 1350
 	if in.Revision != nil {
1351
-		out.Revision = new(apiv1beta3.SourceRevision)
1352
-		if err := convert_api_SourceRevision_To_v1beta3_SourceRevision(in.Revision, out.Revision, s); err != nil {
1351
+		if err := s.Convert(&in.Revision, &out.Revision, 0); err != nil {
1353 1352
 			return err
1354 1353
 		}
1355 1354
 	} else {
... ...
@@ -1406,7 +1405,6 @@ func autoconvert_api_BuildSource_To_v1beta3_BuildSource(in *buildapi.BuildSource
1406 1406
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
1407 1407
 		defaulting.(func(*buildapi.BuildSource))(in)
1408 1408
 	}
1409
-	out.Type = apiv1beta3.BuildSourceType(in.Type)
1410 1409
 	if in.Binary != nil {
1411 1410
 		out.Binary = new(apiv1beta3.BinaryBuildSource)
1412 1411
 		if err := convert_api_BinaryBuildSource_To_v1beta3_BinaryBuildSource(in.Binary, out.Binary, s); err != nil {
... ...
@@ -1441,27 +1439,22 @@ func autoconvert_api_BuildSource_To_v1beta3_BuildSource(in *buildapi.BuildSource
1441 1441
 	return nil
1442 1442
 }
1443 1443
 
1444
-func convert_api_BuildSource_To_v1beta3_BuildSource(in *buildapi.BuildSource, out *apiv1beta3.BuildSource, s conversion.Scope) error {
1445
-	return autoconvert_api_BuildSource_To_v1beta3_BuildSource(in, out, s)
1446
-}
1447
-
1448 1444
 func autoconvert_api_BuildSpec_To_v1beta3_BuildSpec(in *buildapi.BuildSpec, out *apiv1beta3.BuildSpec, s conversion.Scope) error {
1449 1445
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
1450 1446
 		defaulting.(func(*buildapi.BuildSpec))(in)
1451 1447
 	}
1452 1448
 	out.ServiceAccount = in.ServiceAccount
1453
-	if err := convert_api_BuildSource_To_v1beta3_BuildSource(&in.Source, &out.Source, s); err != nil {
1449
+	if err := s.Convert(&in.Source, &out.Source, 0); err != nil {
1454 1450
 		return err
1455 1451
 	}
1456 1452
 	if in.Revision != nil {
1457
-		out.Revision = new(apiv1beta3.SourceRevision)
1458
-		if err := convert_api_SourceRevision_To_v1beta3_SourceRevision(in.Revision, out.Revision, s); err != nil {
1453
+		if err := s.Convert(&in.Revision, &out.Revision, 0); err != nil {
1459 1454
 			return err
1460 1455
 		}
1461 1456
 	} else {
1462 1457
 		out.Revision = nil
1463 1458
 	}
1464
-	if err := convert_api_BuildStrategy_To_v1beta3_BuildStrategy(&in.Strategy, &out.Strategy, s); err != nil {
1459
+	if err := s.Convert(&in.Strategy, &out.Strategy, 0); err != nil {
1465 1460
 		return err
1466 1461
 	}
1467 1462
 	if err := s.Convert(&in.Output, &out.Output, 0); err != nil {
... ...
@@ -1526,7 +1519,6 @@ func autoconvert_api_BuildStrategy_To_v1beta3_BuildStrategy(in *buildapi.BuildSt
1526 1526
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
1527 1527
 		defaulting.(func(*buildapi.BuildStrategy))(in)
1528 1528
 	}
1529
-	out.Type = apiv1beta3.BuildStrategyType(in.Type)
1530 1529
 	if in.DockerStrategy != nil {
1531 1530
 		if err := s.Convert(&in.DockerStrategy, &out.DockerStrategy, 0); err != nil {
1532 1531
 			return err
... ...
@@ -1551,10 +1543,6 @@ func autoconvert_api_BuildStrategy_To_v1beta3_BuildStrategy(in *buildapi.BuildSt
1551 1551
 	return nil
1552 1552
 }
1553 1553
 
1554
-func convert_api_BuildStrategy_To_v1beta3_BuildStrategy(in *buildapi.BuildStrategy, out *apiv1beta3.BuildStrategy, s conversion.Scope) error {
1555
-	return autoconvert_api_BuildStrategy_To_v1beta3_BuildStrategy(in, out, s)
1556
-}
1557
-
1558 1554
 func autoconvert_api_BuildTriggerPolicy_To_v1beta3_BuildTriggerPolicy(in *buildapi.BuildTriggerPolicy, out *apiv1beta3.BuildTriggerPolicy, s conversion.Scope) error {
1559 1555
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
1560 1556
 		defaulting.(func(*buildapi.BuildTriggerPolicy))(in)
... ...
@@ -1779,7 +1767,6 @@ func autoconvert_api_SourceRevision_To_v1beta3_SourceRevision(in *buildapi.Sourc
1779 1779
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
1780 1780
 		defaulting.(func(*buildapi.SourceRevision))(in)
1781 1781
 	}
1782
-	out.Type = apiv1beta3.BuildSourceType(in.Type)
1783 1782
 	if in.Git != nil {
1784 1783
 		out.Git = new(apiv1beta3.GitSourceRevision)
1785 1784
 		if err := convert_api_GitSourceRevision_To_v1beta3_GitSourceRevision(in.Git, out.Git, s); err != nil {
... ...
@@ -1791,10 +1778,6 @@ func autoconvert_api_SourceRevision_To_v1beta3_SourceRevision(in *buildapi.Sourc
1791 1791
 	return nil
1792 1792
 }
1793 1793
 
1794
-func convert_api_SourceRevision_To_v1beta3_SourceRevision(in *buildapi.SourceRevision, out *apiv1beta3.SourceRevision, s conversion.Scope) error {
1795
-	return autoconvert_api_SourceRevision_To_v1beta3_SourceRevision(in, out, s)
1796
-}
1797
-
1798 1794
 func autoconvert_api_WebHookTrigger_To_v1beta3_WebHookTrigger(in *buildapi.WebHookTrigger, out *apiv1beta3.WebHookTrigger, s conversion.Scope) error {
1799 1795
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
1800 1796
 		defaulting.(func(*buildapi.WebHookTrigger))(in)
... ...
@@ -2077,8 +2060,7 @@ func autoconvert_v1beta3_BuildRequest_To_api_BuildRequest(in *apiv1beta3.BuildRe
2077 2077
 		return err
2078 2078
 	}
2079 2079
 	if in.Revision != nil {
2080
-		out.Revision = new(buildapi.SourceRevision)
2081
-		if err := convert_v1beta3_SourceRevision_To_api_SourceRevision(in.Revision, out.Revision, s); err != nil {
2080
+		if err := s.Convert(&in.Revision, &out.Revision, 0); err != nil {
2082 2081
 			return err
2083 2082
 		}
2084 2083
 	} else {
... ...
@@ -2135,7 +2117,7 @@ func autoconvert_v1beta3_BuildSource_To_api_BuildSource(in *apiv1beta3.BuildSour
2135 2135
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
2136 2136
 		defaulting.(func(*apiv1beta3.BuildSource))(in)
2137 2137
 	}
2138
-	out.Type = buildapi.BuildSourceType(in.Type)
2138
+	// in.Type has no peer in out
2139 2139
 	if in.Binary != nil {
2140 2140
 		out.Binary = new(buildapi.BinaryBuildSource)
2141 2141
 		if err := convert_v1beta3_BinaryBuildSource_To_api_BinaryBuildSource(in.Binary, out.Binary, s); err != nil {
... ...
@@ -2170,27 +2152,22 @@ func autoconvert_v1beta3_BuildSource_To_api_BuildSource(in *apiv1beta3.BuildSour
2170 2170
 	return nil
2171 2171
 }
2172 2172
 
2173
-func convert_v1beta3_BuildSource_To_api_BuildSource(in *apiv1beta3.BuildSource, out *buildapi.BuildSource, s conversion.Scope) error {
2174
-	return autoconvert_v1beta3_BuildSource_To_api_BuildSource(in, out, s)
2175
-}
2176
-
2177 2173
 func autoconvert_v1beta3_BuildSpec_To_api_BuildSpec(in *apiv1beta3.BuildSpec, out *buildapi.BuildSpec, s conversion.Scope) error {
2178 2174
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
2179 2175
 		defaulting.(func(*apiv1beta3.BuildSpec))(in)
2180 2176
 	}
2181 2177
 	out.ServiceAccount = in.ServiceAccount
2182
-	if err := convert_v1beta3_BuildSource_To_api_BuildSource(&in.Source, &out.Source, s); err != nil {
2178
+	if err := s.Convert(&in.Source, &out.Source, 0); err != nil {
2183 2179
 		return err
2184 2180
 	}
2185 2181
 	if in.Revision != nil {
2186
-		out.Revision = new(buildapi.SourceRevision)
2187
-		if err := convert_v1beta3_SourceRevision_To_api_SourceRevision(in.Revision, out.Revision, s); err != nil {
2182
+		if err := s.Convert(&in.Revision, &out.Revision, 0); err != nil {
2188 2183
 			return err
2189 2184
 		}
2190 2185
 	} else {
2191 2186
 		out.Revision = nil
2192 2187
 	}
2193
-	if err := convert_v1beta3_BuildStrategy_To_api_BuildStrategy(&in.Strategy, &out.Strategy, s); err != nil {
2188
+	if err := s.Convert(&in.Strategy, &out.Strategy, 0); err != nil {
2194 2189
 		return err
2195 2190
 	}
2196 2191
 	if err := s.Convert(&in.Output, &out.Output, 0); err != nil {
... ...
@@ -2255,7 +2232,7 @@ func autoconvert_v1beta3_BuildStrategy_To_api_BuildStrategy(in *apiv1beta3.Build
2255 2255
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
2256 2256
 		defaulting.(func(*apiv1beta3.BuildStrategy))(in)
2257 2257
 	}
2258
-	out.Type = buildapi.BuildStrategyType(in.Type)
2258
+	// in.Type has no peer in out
2259 2259
 	if in.DockerStrategy != nil {
2260 2260
 		if err := s.Convert(&in.DockerStrategy, &out.DockerStrategy, 0); err != nil {
2261 2261
 			return err
... ...
@@ -2280,10 +2257,6 @@ func autoconvert_v1beta3_BuildStrategy_To_api_BuildStrategy(in *apiv1beta3.Build
2280 2280
 	return nil
2281 2281
 }
2282 2282
 
2283
-func convert_v1beta3_BuildStrategy_To_api_BuildStrategy(in *apiv1beta3.BuildStrategy, out *buildapi.BuildStrategy, s conversion.Scope) error {
2284
-	return autoconvert_v1beta3_BuildStrategy_To_api_BuildStrategy(in, out, s)
2285
-}
2286
-
2287 2283
 func autoconvert_v1beta3_BuildTriggerPolicy_To_api_BuildTriggerPolicy(in *apiv1beta3.BuildTriggerPolicy, out *buildapi.BuildTriggerPolicy, s conversion.Scope) error {
2288 2284
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
2289 2285
 		defaulting.(func(*apiv1beta3.BuildTriggerPolicy))(in)
... ...
@@ -2508,7 +2481,7 @@ func autoconvert_v1beta3_SourceRevision_To_api_SourceRevision(in *apiv1beta3.Sou
2508 2508
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
2509 2509
 		defaulting.(func(*apiv1beta3.SourceRevision))(in)
2510 2510
 	}
2511
-	out.Type = buildapi.BuildSourceType(in.Type)
2511
+	// in.Type has no peer in out
2512 2512
 	if in.Git != nil {
2513 2513
 		out.Git = new(buildapi.GitSourceRevision)
2514 2514
 		if err := convert_v1beta3_GitSourceRevision_To_api_GitSourceRevision(in.Git, out.Git, s); err != nil {
... ...
@@ -2520,10 +2493,6 @@ func autoconvert_v1beta3_SourceRevision_To_api_SourceRevision(in *apiv1beta3.Sou
2520 2520
 	return nil
2521 2521
 }
2522 2522
 
2523
-func convert_v1beta3_SourceRevision_To_api_SourceRevision(in *apiv1beta3.SourceRevision, out *buildapi.SourceRevision, s conversion.Scope) error {
2524
-	return autoconvert_v1beta3_SourceRevision_To_api_SourceRevision(in, out, s)
2525
-}
2526
-
2527 2523
 func autoconvert_v1beta3_WebHookTrigger_To_api_WebHookTrigger(in *apiv1beta3.WebHookTrigger, out *buildapi.WebHookTrigger, s conversion.Scope) error {
2528 2524
 	if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found {
2529 2525
 		defaulting.(func(*apiv1beta3.WebHookTrigger))(in)
... ...
@@ -61,18 +61,16 @@ func (a *buildByStrategy) Admit(attr admission.Attributes) error {
61 61
 	}
62 62
 }
63 63
 
64
-func resourceForStrategyType(strategyType buildapi.BuildStrategyType) string {
65
-	var resource string
66
-	switch strategyType {
67
-	case buildapi.DockerBuildStrategyType:
68
-		resource = authorizationapi.DockerBuildResource
69
-	case buildapi.CustomBuildStrategyType:
70
-		resource = authorizationapi.CustomBuildResource
71
-	case buildapi.SourceBuildStrategyType:
72
-		resource = authorizationapi.SourceBuildResource
64
+func resourceForStrategyType(strategy buildapi.BuildStrategy) string {
65
+	switch {
66
+	case strategy.DockerStrategy != nil:
67
+		return authorizationapi.DockerBuildResource
68
+	case strategy.CustomStrategy != nil:
69
+		return authorizationapi.CustomBuildResource
70
+	case strategy.SourceStrategy != nil:
71
+		return authorizationapi.SourceBuildResource
73 72
 	}
74
-	return resource
75
-
73
+	return ""
76 74
 }
77 75
 
78 76
 func resourceName(objectMeta kapi.ObjectMeta) string {
... ...
@@ -83,33 +81,33 @@ func resourceName(objectMeta kapi.ObjectMeta) string {
83 83
 }
84 84
 
85 85
 func (a *buildByStrategy) checkBuildAuthorization(build *buildapi.Build, attr admission.Attributes) error {
86
-	strategyType := build.Spec.Strategy.Type
86
+	strategy := build.Spec.Strategy
87 87
 	subjectAccessReview := &authorizationapi.LocalSubjectAccessReview{
88 88
 		Action: authorizationapi.AuthorizationAttributes{
89 89
 			Verb:         "create",
90
-			Resource:     resourceForStrategyType(strategyType),
90
+			Resource:     resourceForStrategyType(strategy),
91 91
 			Content:      runtime.EmbeddedObject{Object: build},
92 92
 			ResourceName: resourceName(build.ObjectMeta),
93 93
 		},
94 94
 		User:   attr.GetUserInfo().GetName(),
95 95
 		Groups: sets.NewString(attr.GetUserInfo().GetGroups()...),
96 96
 	}
97
-	return a.checkAccess(strategyType, subjectAccessReview, attr)
97
+	return a.checkAccess(strategy, subjectAccessReview, attr)
98 98
 }
99 99
 
100 100
 func (a *buildByStrategy) checkBuildConfigAuthorization(buildConfig *buildapi.BuildConfig, attr admission.Attributes) error {
101
-	strategyType := buildConfig.Spec.Strategy.Type
101
+	strategy := buildConfig.Spec.Strategy
102 102
 	subjectAccessReview := &authorizationapi.LocalSubjectAccessReview{
103 103
 		Action: authorizationapi.AuthorizationAttributes{
104 104
 			Verb:         "create",
105
-			Resource:     resourceForStrategyType(strategyType),
105
+			Resource:     resourceForStrategyType(strategy),
106 106
 			Content:      runtime.EmbeddedObject{Object: buildConfig},
107 107
 			ResourceName: resourceName(buildConfig.ObjectMeta),
108 108
 		},
109 109
 		User:   attr.GetUserInfo().GetName(),
110 110
 		Groups: sets.NewString(attr.GetUserInfo().GetGroups()...),
111 111
 	}
112
-	return a.checkAccess(strategyType, subjectAccessReview, attr)
112
+	return a.checkAccess(strategy, subjectAccessReview, attr)
113 113
 }
114 114
 
115 115
 func (a *buildByStrategy) checkBuildRequestAuthorization(req *buildapi.BuildRequest, attr admission.Attributes) error {
... ...
@@ -131,17 +129,17 @@ func (a *buildByStrategy) checkBuildRequestAuthorization(req *buildapi.BuildRequ
131 131
 	}
132 132
 }
133 133
 
134
-func (a *buildByStrategy) checkAccess(strategyType buildapi.BuildStrategyType, subjectAccessReview *authorizationapi.LocalSubjectAccessReview, attr admission.Attributes) error {
134
+func (a *buildByStrategy) checkAccess(strategy buildapi.BuildStrategy, subjectAccessReview *authorizationapi.LocalSubjectAccessReview, attr admission.Attributes) error {
135 135
 	resp, err := a.client.LocalSubjectAccessReviews(attr.GetNamespace()).Create(subjectAccessReview)
136 136
 	if err != nil {
137 137
 		return err
138 138
 	}
139 139
 	if !resp.Allowed {
140
-		return notAllowed(strategyType, attr)
140
+		return notAllowed(strategy, attr)
141 141
 	}
142 142
 	return nil
143 143
 }
144 144
 
145
-func notAllowed(strategyType buildapi.BuildStrategyType, attr admission.Attributes) error {
146
-	return admission.NewForbidden(attr, fmt.Errorf("build strategy type %s is not allowed", strategyType))
145
+func notAllowed(strategy buildapi.BuildStrategy, attr admission.Attributes) error {
146
+	return admission.NewForbidden(attr, fmt.Errorf("build strategy %s is not allowed", buildapi.StrategyType(strategy)))
147 147
 }
... ...
@@ -32,7 +32,7 @@ func TestBuildAdmission(t *testing.T) {
32 32
 	}{
33 33
 		{
34 34
 			name:             "allowed source build",
35
-			object:           testBuild(buildapi.SourceBuildStrategyType),
35
+			object:           testBuild(buildapi.BuildStrategy{SourceStrategy: &buildapi.SourceBuildStrategy{}}),
36 36
 			kind:             "Build",
37 37
 			resource:         buildsResource,
38 38
 			reviewResponse:   reviewResponse(true, ""),
... ...
@@ -42,7 +42,7 @@ func TestBuildAdmission(t *testing.T) {
42 42
 		{
43 43
 			name:             "allowed source build clone",
44 44
 			object:           testBuildRequest("buildname"),
45
-			responseObject:   testBuild(buildapi.SourceBuildStrategyType),
45
+			responseObject:   testBuild(buildapi.BuildStrategy{SourceStrategy: &buildapi.SourceBuildStrategy{}}),
46 46
 			kind:             "Build",
47 47
 			resource:         buildsResource,
48 48
 			subResource:      "clone",
... ...
@@ -52,7 +52,7 @@ func TestBuildAdmission(t *testing.T) {
52 52
 		},
53 53
 		{
54 54
 			name:             "denied docker build",
55
-			object:           testBuild(buildapi.DockerBuildStrategyType),
55
+			object:           testBuild(buildapi.BuildStrategy{DockerStrategy: &buildapi.DockerBuildStrategy{}}),
56 56
 			kind:             "Build",
57 57
 			resource:         buildsResource,
58 58
 			reviewResponse:   reviewResponse(false, "cannot create build of type docker build"),
... ...
@@ -62,7 +62,7 @@ func TestBuildAdmission(t *testing.T) {
62 62
 		{
63 63
 			name:             "denied docker build clone",
64 64
 			object:           testBuildRequest("buildname"),
65
-			responseObject:   testBuild(buildapi.DockerBuildStrategyType),
65
+			responseObject:   testBuild(buildapi.BuildStrategy{DockerStrategy: &buildapi.DockerBuildStrategy{}}),
66 66
 			kind:             "Build",
67 67
 			resource:         buildsResource,
68 68
 			subResource:      "clone",
... ...
@@ -72,7 +72,7 @@ func TestBuildAdmission(t *testing.T) {
72 72
 		},
73 73
 		{
74 74
 			name:             "allowed custom build",
75
-			object:           testBuild(buildapi.CustomBuildStrategyType),
75
+			object:           testBuild(buildapi.BuildStrategy{CustomStrategy: &buildapi.CustomBuildStrategy{}}),
76 76
 			kind:             "Build",
77 77
 			resource:         buildsResource,
78 78
 			reviewResponse:   reviewResponse(true, ""),
... ...
@@ -81,7 +81,7 @@ func TestBuildAdmission(t *testing.T) {
81 81
 		},
82 82
 		{
83 83
 			name:             "allowed build config",
84
-			object:           testBuildConfig(buildapi.DockerBuildStrategyType),
84
+			object:           testBuildConfig(buildapi.BuildStrategy{DockerStrategy: &buildapi.DockerBuildStrategy{}}),
85 85
 			kind:             "BuildConfig",
86 86
 			resource:         buildConfigsResource,
87 87
 			reviewResponse:   reviewResponse(true, ""),
... ...
@@ -90,7 +90,7 @@ func TestBuildAdmission(t *testing.T) {
90 90
 		},
91 91
 		{
92 92
 			name:             "allowed build config instantiate",
93
-			responseObject:   testBuildConfig(buildapi.DockerBuildStrategyType),
93
+			responseObject:   testBuildConfig(buildapi.BuildStrategy{DockerStrategy: &buildapi.DockerBuildStrategy{}}),
94 94
 			object:           testBuildRequest("buildname"),
95 95
 			kind:             "BuildConfig",
96 96
 			resource:         buildConfigsResource,
... ...
@@ -101,7 +101,7 @@ func TestBuildAdmission(t *testing.T) {
101 101
 		},
102 102
 		{
103 103
 			name:             "forbidden build config",
104
-			object:           testBuildConfig(buildapi.CustomBuildStrategyType),
104
+			object:           testBuildConfig(buildapi.BuildStrategy{CustomStrategy: &buildapi.CustomBuildStrategy{}}),
105 105
 			kind:             "BuildConfig",
106 106
 			resource:         buildConfigsResource,
107 107
 			reviewResponse:   reviewResponse(false, ""),
... ...
@@ -110,7 +110,7 @@ func TestBuildAdmission(t *testing.T) {
110 110
 		},
111 111
 		{
112 112
 			name:             "forbidden build config instantiate",
113
-			responseObject:   testBuildConfig(buildapi.CustomBuildStrategyType),
113
+			responseObject:   testBuildConfig(buildapi.BuildStrategy{CustomStrategy: &buildapi.CustomBuildStrategy{}}),
114 114
 			object:           testBuildRequest("buildname"),
115 115
 			kind:             "BuildConfig",
116 116
 			resource:         buildConfigsResource,
... ...
@@ -182,29 +182,25 @@ func fakeClient(expectedResource string, reviewResponse *authorizationapi.Subjec
182 182
 	return fake
183 183
 }
184 184
 
185
-func testBuild(strategy buildapi.BuildStrategyType) *buildapi.Build {
185
+func testBuild(strategy buildapi.BuildStrategy) *buildapi.Build {
186 186
 	return &buildapi.Build{
187 187
 		ObjectMeta: kapi.ObjectMeta{
188 188
 			Name: "test-build",
189 189
 		},
190 190
 		Spec: buildapi.BuildSpec{
191
-			Strategy: buildapi.BuildStrategy{
192
-				Type: strategy,
193
-			},
191
+			Strategy: strategy,
194 192
 		},
195 193
 	}
196 194
 }
197 195
 
198
-func testBuildConfig(strategy buildapi.BuildStrategyType) *buildapi.BuildConfig {
196
+func testBuildConfig(strategy buildapi.BuildStrategy) *buildapi.BuildConfig {
199 197
 	return &buildapi.BuildConfig{
200 198
 		ObjectMeta: kapi.ObjectMeta{
201 199
 			Name: "test-buildconfig",
202 200
 		},
203 201
 		Spec: buildapi.BuildConfigSpec{
204 202
 			BuildSpec: buildapi.BuildSpec{
205
-				Strategy: buildapi.BuildStrategy{
206
-					Type: strategy,
207
-				},
203
+				Strategy: strategy,
208 204
 			},
209 205
 		},
210 206
 	}
... ...
@@ -166,24 +166,8 @@ const (
166 166
 	StatusReasonExceededRetryTimeout = "ExceededRetryTimeout"
167 167
 )
168 168
 
169
-// BuildSourceType is the type of SCM used.
170
-type BuildSourceType string
171
-
172
-// Valid values for BuildSourceType.
173
-const (
174
-	//BuildSourceGit instructs a build to use a Git source control repository as the build input.
175
-	BuildSourceGit BuildSourceType = "Git"
176
-	// BuildSourceDockerfile uses a Dockerfile as the start of a build
177
-	BuildSourceDockerfile BuildSourceType = "Dockerfile"
178
-	// BuildSourceBinary indicates the build will accept a Binary file as input.
179
-	BuildSourceBinary BuildSourceType = "Binary"
180
-)
181
-
182 169
 // BuildSource is the input used for the build.
183 170
 type BuildSource struct {
184
-	// Type of build input to accept
185
-	Type BuildSourceType
186
-
187 171
 	// Binary builds accept a binary as their input. The binary is generally assumed to be a tar,
188 172
 	// gzipped tar, or zip file depending on the strategy. For Docker builds, this is the build
189 173
 	// context and an optional Dockerfile may be specified to override any Dockerfile in the
... ...
@@ -229,9 +213,6 @@ type BinaryBuildSource struct {
229 229
 
230 230
 // SourceRevision is the revision or commit information from the source for the build
231 231
 type SourceRevision struct {
232
-	// Type of the build source
233
-	Type BuildSourceType
234
-
235 232
 	// Git contains information about git-based build source
236 233
 	Git *GitSourceRevision
237 234
 }
... ...
@@ -278,9 +259,6 @@ type SourceControlUser struct {
278 278
 
279 279
 // BuildStrategy contains the details of how to perform a build.
280 280
 type BuildStrategy struct {
281
-	// Type is the kind of build strategy.
282
-	Type BuildStrategyType
283
-
284 281
 	// DockerStrategy holds the parameters to the Docker build strategy.
285 282
 	DockerStrategy *DockerBuildStrategy
286 283
 
... ...
@@ -294,19 +272,6 @@ type BuildStrategy struct {
294 294
 // BuildStrategyType describes a particular way of performing a build.
295 295
 type BuildStrategyType string
296 296
 
297
-// Valid values for BuildStrategyType.
298
-const (
299
-	// DockerBuildStrategyType performs builds using a Dockerfile.
300
-	DockerBuildStrategyType BuildStrategyType = "Docker"
301
-
302
-	// SourceBuildStrategyType performs builds build using Source To Images with a Git repository
303
-	// and a builder image.
304
-	SourceBuildStrategyType BuildStrategyType = "Source"
305
-
306
-	// CustomBuildStrategyType performs builds using custom builder Docker image.
307
-	CustomBuildStrategyType BuildStrategyType = "Custom"
308
-)
309
-
310 297
 const (
311 298
 	// CustomBuildStrategyBaseImageKey is the environment variable that indicates the base image to be used when
312 299
 	// performing a custom build, if needed.
... ...
@@ -526,10 +491,7 @@ type BuildConfigList struct {
526 526
 
527 527
 // GenericWebHookEvent is the payload expected for a generic webhook post
528 528
 type GenericWebHookEvent struct {
529
-	// Type is the type of source repository
530
-	Type BuildSourceType
531
-
532
-	// Git is the git information if the Type is BuildSourceGit
529
+	// Git is the git information, if any.
533 530
 	Git *GitInfo
534 531
 }
535 532
 
... ...
@@ -11,3 +11,35 @@ const (
11 11
 func GetBuildPodName(build *Build) string {
12 12
 	return namer.GetPodName(build.Name, BuildPodSuffix)
13 13
 }
14
+
15
+func StrategyType(strategy BuildStrategy) string {
16
+	switch {
17
+	case strategy.DockerStrategy != nil:
18
+		return "Docker"
19
+	case strategy.CustomStrategy != nil:
20
+		return "Custom"
21
+	case strategy.SourceStrategy != nil:
22
+		return "Source"
23
+	}
24
+	return ""
25
+}
26
+
27
+func SourceType(source BuildSource) string {
28
+	var sourceType string
29
+	if source.Git != nil {
30
+		sourceType = "Git"
31
+	}
32
+	if source.Dockerfile != nil {
33
+		if len(sourceType) != 0 {
34
+			sourceType = sourceType + ","
35
+		}
36
+		sourceType = sourceType + "Dockerfile"
37
+	}
38
+	if source.Binary != nil {
39
+		if len(sourceType) != 0 {
40
+			sourceType = sourceType + ","
41
+		}
42
+		sourceType = sourceType + "Binary"
43
+	}
44
+	return sourceType
45
+}
... ...
@@ -113,6 +113,69 @@ func convert_v1_BuildTriggerPolicy_To_api_BuildTriggerPolicy(in *BuildTriggerPol
113 113
 	return nil
114 114
 }
115 115
 
116
+func convert_api_SourceRevision_To_v1_SourceRevision(in *newer.SourceRevision, out *SourceRevision, s conversion.Scope) error {
117
+	if err := s.DefaultConvert(in, out, conversion.IgnoreMissingFields); err != nil {
118
+		return err
119
+	}
120
+	out.Type = BuildSourceGit
121
+	return nil
122
+}
123
+
124
+func convert_v1_SourceRevision_To_api_SourceRevision(in *SourceRevision, out *newer.SourceRevision, s conversion.Scope) error {
125
+	if err := s.DefaultConvert(in, out, conversion.IgnoreMissingFields); err != nil {
126
+		return err
127
+	}
128
+	return nil
129
+}
130
+
131
+func convert_api_BuildSource_To_v1_BuildSource(in *newer.BuildSource, out *BuildSource, s conversion.Scope) error {
132
+	if err := s.DefaultConvert(in, out, conversion.IgnoreMissingFields); err != nil {
133
+		return err
134
+	}
135
+	switch {
136
+	// it is legal for a buildsource to have both a git+dockerfile source, but in v1 that was represented
137
+	// as type git.
138
+	case in.Git != nil:
139
+		out.Type = BuildSourceGit
140
+	// it is legal for a buildsource to have both a binary+dockerfile source, but in v1 that was represented
141
+	// as type binary.
142
+	case in.Binary != nil:
143
+		out.Type = BuildSourceBinary
144
+	case in.Dockerfile != nil:
145
+		out.Type = BuildSourceDockerfile
146
+	}
147
+	return nil
148
+}
149
+
150
+func convert_v1_BuildSource_To_api_BuildSource(in *BuildSource, out *newer.BuildSource, s conversion.Scope) error {
151
+	if err := s.DefaultConvert(in, out, conversion.IgnoreMissingFields); err != nil {
152
+		return err
153
+	}
154
+	return nil
155
+}
156
+
157
+func convert_api_BuildStrategy_To_v1_BuildStrategy(in *newer.BuildStrategy, out *BuildStrategy, s conversion.Scope) error {
158
+	if err := s.DefaultConvert(in, out, conversion.IgnoreMissingFields); err != nil {
159
+		return err
160
+	}
161
+	switch {
162
+	case in.SourceStrategy != nil:
163
+		out.Type = SourceBuildStrategyType
164
+	case in.DockerStrategy != nil:
165
+		out.Type = DockerBuildStrategyType
166
+	case in.CustomStrategy != nil:
167
+		out.Type = CustomBuildStrategyType
168
+	}
169
+	return nil
170
+}
171
+
172
+func convert_v1_BuildStrategy_To_api_BuildStrategy(in *BuildStrategy, out *newer.BuildStrategy, s conversion.Scope) error {
173
+	if err := s.DefaultConvert(in, out, conversion.IgnoreMissingFields); err != nil {
174
+		return err
175
+	}
176
+	return nil
177
+}
178
+
116 179
 func init() {
117 180
 	err := kapi.Scheme.AddDefaultingFuncs(
118 181
 		func(strategy *BuildStrategy) {
... ...
@@ -159,6 +222,12 @@ func init() {
159 159
 		convert_api_BuildOutput_To_v1_BuildOutput,
160 160
 		convert_v1_BuildTriggerPolicy_To_api_BuildTriggerPolicy,
161 161
 		convert_api_BuildTriggerPolicy_To_v1_BuildTriggerPolicy,
162
+		convert_v1_SourceRevision_To_api_SourceRevision,
163
+		convert_api_SourceRevision_To_v1_SourceRevision,
164
+		convert_v1_BuildSource_To_api_BuildSource,
165
+		convert_api_BuildSource_To_v1_BuildSource,
166
+		convert_v1_BuildStrategy_To_api_BuildStrategy,
167
+		convert_api_BuildStrategy_To_v1_BuildStrategy,
162 168
 	)
163 169
 
164 170
 	if err := kapi.Scheme.AddFieldLabelConversionFunc("v1", "Build",
... ...
@@ -121,6 +121,68 @@ func convert_api_BuildTriggerPolicy_To_v1beta3_BuildTriggerPolicy(in *newer.Buil
121 121
 	return nil
122 122
 }
123 123
 
124
+func convert_v1beta3_SourceRevision_To_api_SourceRevision(in *SourceRevision, out *newer.SourceRevision, s conversion.Scope) error {
125
+	if err := s.DefaultConvert(in, out, conversion.IgnoreMissingFields); err != nil {
126
+		return err
127
+	}
128
+	return nil
129
+}
130
+
131
+func convert_api_SourceRevision_To_v1beta3_SourceRevision(in *newer.SourceRevision, out *SourceRevision, s conversion.Scope) error {
132
+	if err := s.DefaultConvert(in, out, conversion.IgnoreMissingFields); err != nil {
133
+		return err
134
+	}
135
+	out.Type = BuildSourceGit
136
+	return nil
137
+}
138
+
139
+func convert_v1beta3_BuildSource_To_api_BuildSource(in *BuildSource, out *newer.BuildSource, s conversion.Scope) error {
140
+	if err := s.DefaultConvert(in, out, conversion.IgnoreMissingFields); err != nil {
141
+		return err
142
+	}
143
+	return nil
144
+}
145
+
146
+func convert_api_BuildSource_To_v1beta3_BuildSource(in *newer.BuildSource, out *BuildSource, s conversion.Scope) error {
147
+	if err := s.DefaultConvert(in, out, conversion.IgnoreMissingFields); err != nil {
148
+		return err
149
+	}
150
+	switch {
151
+	// it is legal for a buildsource to have both a git+dockerfile source, but in v1 that was represented
152
+	// as type git.
153
+	case in.Git != nil:
154
+		out.Type = BuildSourceGit
155
+	// it is legal for a buildsource to have both a binary+dockerfile source, but in v1 that was represented
156
+	// as type binary.
157
+	case in.Binary != nil:
158
+		out.Type = BuildSourceBinary
159
+	case in.Dockerfile != nil:
160
+		out.Type = BuildSourceDockerfile
161
+	}
162
+	return nil
163
+}
164
+
165
+func convert_v1beta3_BuildStrategy_To_api_BuildStrategy(in *BuildStrategy, out *newer.BuildStrategy, s conversion.Scope) error {
166
+	if err := s.DefaultConvert(in, out, conversion.IgnoreMissingFields); err != nil {
167
+		return err
168
+	}
169
+	return nil
170
+}
171
+
172
+func convert_api_BuildStrategy_To_v1beta3_BuildStrategy(in *newer.BuildStrategy, out *BuildStrategy, s conversion.Scope) error {
173
+	if err := s.DefaultConvert(in, out, conversion.IgnoreMissingFields); err != nil {
174
+		return err
175
+	}
176
+	switch {
177
+	case in.SourceStrategy != nil:
178
+		out.Type = SourceBuildStrategyType
179
+	case in.DockerStrategy != nil:
180
+		out.Type = DockerBuildStrategyType
181
+	case in.CustomStrategy != nil:
182
+		out.Type = CustomBuildStrategyType
183
+	}
184
+	return nil
185
+}
124 186
 func init() {
125 187
 	err := kapi.Scheme.AddDefaultingFuncs(
126 188
 		func(strategy *BuildStrategy) {
... ...
@@ -167,6 +229,12 @@ func init() {
167 167
 		convert_api_BuildOutput_To_v1beta3_BuildOutput,
168 168
 		convert_v1beta3_BuildTriggerPolicy_To_api_BuildTriggerPolicy,
169 169
 		convert_api_BuildTriggerPolicy_To_v1beta3_BuildTriggerPolicy,
170
+		convert_v1beta3_SourceRevision_To_api_SourceRevision,
171
+		convert_api_SourceRevision_To_v1beta3_SourceRevision,
172
+		convert_v1beta3_BuildSource_To_api_BuildSource,
173
+		convert_api_BuildSource_To_v1beta3_BuildSource,
174
+		convert_v1beta3_BuildStrategy_To_api_BuildStrategy,
175
+		convert_api_BuildStrategy_To_v1beta3_BuildStrategy,
170 176
 	)
171 177
 
172 178
 	// Add field conversion funcs.
... ...
@@ -82,7 +82,7 @@ func ValidateBuildConfig(config *buildapi.BuildConfig) fielderrors.ValidationErr
82 82
 
83 83
 	// validate ImageChangeTriggers of DockerStrategy builds
84 84
 	strategy := config.Spec.BuildSpec.Strategy
85
-	if strategy.Type == buildapi.DockerBuildStrategyType && strategy.DockerStrategy.From == nil {
85
+	if strategy.DockerStrategy != nil && strategy.DockerStrategy.From == nil {
86 86
 		for _, trigger := range config.Spec.Triggers {
87 87
 			if trigger.Type == buildapi.ImageChangeBuildTriggerType && (trigger.ImageChange == nil || trigger.ImageChange.From == nil) {
88 88
 				allErrs = append(allErrs, fielderrors.NewFieldRequired("imageChange.from"))
... ...
@@ -106,30 +106,19 @@ func ValidateBuildRequest(request *buildapi.BuildRequest) fielderrors.Validation
106 106
 	allErrs := fielderrors.ValidationErrorList{}
107 107
 	allErrs = append(allErrs, validation.ValidateObjectMeta(&request.ObjectMeta, true, oapi.MinimalNameRequirements).Prefix("metadata")...)
108 108
 
109
-	if request.Revision != nil {
110
-		allErrs = append(allErrs, validateRevision(request.Revision).Prefix("revision")...)
111
-	}
112 109
 	return allErrs
113 110
 }
114 111
 
115 112
 func validateBuildSpec(spec *buildapi.BuildSpec) fielderrors.ValidationErrorList {
116 113
 	allErrs := fielderrors.ValidationErrorList{}
117
-	hasSourceType := len(spec.Source.Type) != 0
118
-	switch t := spec.Strategy.Type; {
119
-	// 'source' is optional for Custom builds
120
-	case t == buildapi.CustomBuildStrategyType && hasSourceType:
121
-		allErrs = append(allErrs, validateSource(&spec.Source).Prefix("source")...)
122
-	case t == buildapi.SourceBuildStrategyType:
123
-		allErrs = append(allErrs, validateSource(&spec.Source).Prefix("source")...)
124
-		if spec.Source.Type == buildapi.BuildSourceDockerfile {
125
-			allErrs = append(allErrs, fielderrors.NewFieldInvalid("source.type", nil, "may not be type Dockerfile for source builds"))
126
-		}
127
-	case t == buildapi.DockerBuildStrategyType:
128
-		allErrs = append(allErrs, validateSource(&spec.Source).Prefix("source")...)
129
-	}
130
-	if spec.Revision != nil {
131
-		allErrs = append(allErrs, validateRevision(spec.Revision).Prefix("revision")...)
114
+	s := spec.Strategy
115
+
116
+	if s.CustomStrategy == nil && spec.Source.Git == nil && spec.Source.Binary == nil && spec.Source.Dockerfile == nil {
117
+		allErrs = append(allErrs, fielderrors.NewFieldInvalid("source", spec.Source, "must provide a value for at least one of source, binary, or dockerfile"))
132 118
 	}
119
+
120
+	allErrs = append(allErrs, validateSource(&spec.Source, s.CustomStrategy != nil).Prefix("source")...)
121
+
133 122
 	if spec.CompletionDeadlineSeconds != nil {
134 123
 		if *spec.CompletionDeadlineSeconds <= 0 {
135 124
 			allErrs = append(allErrs, fielderrors.NewFieldInvalid("completionDeadlineSeconds", spec.CompletionDeadlineSeconds, "completionDeadlineSeconds must be a positive integer greater than 0"))
... ...
@@ -149,52 +138,25 @@ func hasProxy(source *buildapi.GitBuildSource) bool {
149 149
 	return len(source.HTTPProxy) > 0 || len(source.HTTPSProxy) > 0
150 150
 }
151 151
 
152
-func validateSource(input *buildapi.BuildSource) fielderrors.ValidationErrorList {
152
+func validateSource(input *buildapi.BuildSource, isCustomStrategy bool) fielderrors.ValidationErrorList {
153 153
 	allErrs := fielderrors.ValidationErrorList{}
154
-	switch input.Type {
155
-	case buildapi.BuildSourceGit:
156
-		if input.Git == nil {
157
-			allErrs = append(allErrs, fielderrors.NewFieldRequired("git"))
158
-		} else {
159
-			allErrs = append(allErrs, validateGitSource(input.Git).Prefix("git")...)
160
-		}
161
-		if input.Dockerfile != nil {
162
-			allErrs = append(allErrs, validateDockerfile(*input.Dockerfile)...)
163
-		}
164
-		if input.Binary != nil {
165
-			allErrs = append(allErrs, fielderrors.NewFieldInvalid("binary", "", "may not be set when type is Git"))
166
-		}
167
-	case buildapi.BuildSourceBinary:
168
-		if input.Binary == nil {
169
-			allErrs = append(allErrs, fielderrors.NewFieldRequired("binary"))
170
-		} else {
171
-			allErrs = append(allErrs, validateBinarySource(input.Binary).Prefix("binary")...)
172
-		}
173
-		if input.Dockerfile != nil {
174
-			allErrs = append(allErrs, validateDockerfile(*input.Dockerfile)...)
175
-		}
176
-		if input.Git != nil {
177
-			allErrs = append(allErrs, fielderrors.NewFieldInvalid("git", "", "may not be set when type is Binary"))
178
-		}
179
-	case buildapi.BuildSourceDockerfile:
180
-		if input.Dockerfile == nil {
181
-			allErrs = append(allErrs, fielderrors.NewFieldRequired("dockerfile"))
182
-		} else {
183
-			allErrs = append(allErrs, validateDockerfile(*input.Dockerfile)...)
154
+
155
+	if input.Git != nil {
156
+		// git and binary input sources are mutually exclusive
157
+		if input.Binary != nil && !isCustomStrategy {
158
+			return append(allErrs, fielderrors.NewFieldInvalid("binary", "", "may not be set when git also set"))
184 159
 		}
185
-		switch {
186
-		case input.Git != nil && input.Binary != nil:
187
-			allErrs = append(allErrs, fielderrors.NewFieldInvalid("git", "", "may not be set when binary is also set"))
188
-			allErrs = append(allErrs, fielderrors.NewFieldInvalid("binary", "", "may not be set when git is also set"))
189
-		case input.Git != nil:
190
-			allErrs = append(allErrs, validateGitSource(input.Git).Prefix("git")...)
191
-		case input.Binary != nil:
192
-			allErrs = append(allErrs, validateBinarySource(input.Binary).Prefix("binary")...)
160
+		allErrs = append(allErrs, validateGitSource(input.Git).Prefix("git")...)
161
+	}
162
+	if input.Binary != nil {
163
+		// git and binary input sources are mutually exclusive
164
+		if input.Git != nil && !isCustomStrategy {
165
+			return append(allErrs, fielderrors.NewFieldInvalid("git", "", "may not be set when binary is also set"))
193 166
 		}
194
-	case "":
195
-		allErrs = append(allErrs, fielderrors.NewFieldRequired("type"))
196
-	default:
197
-		allErrs = append(allErrs, fielderrors.NewFieldInvalid("type", input.Type, fmt.Sprintf("source type must be one of Git, Dockerfile, or Binary")))
167
+		allErrs = append(allErrs, validateBinarySource(input.Binary).Prefix("binary")...)
168
+	}
169
+	if input.Dockerfile != nil {
170
+		allErrs = append(allErrs, validateDockerfile(*input.Dockerfile)...)
198 171
 	}
199 172
 	allErrs = append(allErrs, validateSecretRef(input.SourceSecret).Prefix("sourceSecret")...)
200 173
 
... ...
@@ -272,15 +234,6 @@ func validateBinarySource(source *buildapi.BinaryBuildSource) fielderrors.Valida
272 272
 	return allErrs
273 273
 }
274 274
 
275
-func validateRevision(revision *buildapi.SourceRevision) fielderrors.ValidationErrorList {
276
-	allErrs := fielderrors.ValidationErrorList{}
277
-	if len(revision.Type) == 0 {
278
-		allErrs = append(allErrs, fielderrors.NewFieldRequired("type"))
279
-	}
280
-	// TODO: validate other stuff
281
-	return allErrs
282
-}
283
-
284 275
 func validateToImageReference(reference *kapi.ObjectReference) fielderrors.ValidationErrorList {
285 276
 	allErrs := fielderrors.ValidationErrorList{}
286 277
 	kind, name, namespace := reference.Kind, reference.Name, reference.Namespace
... ...
@@ -367,32 +320,28 @@ func validateOutput(output *buildapi.BuildOutput) fielderrors.ValidationErrorLis
367 367
 func validateStrategy(strategy *buildapi.BuildStrategy) fielderrors.ValidationErrorList {
368 368
 	allErrs := fielderrors.ValidationErrorList{}
369 369
 
370
-	switch {
371
-	case len(strategy.Type) == 0:
372
-		allErrs = append(allErrs, fielderrors.NewFieldRequired("type"))
373
-
374
-	case strategy.Type == buildapi.SourceBuildStrategyType:
375
-		if strategy.SourceStrategy == nil {
376
-			allErrs = append(allErrs, fielderrors.NewFieldRequired("stiStrategy"))
377
-		} else {
378
-			allErrs = append(allErrs, validateSourceStrategy(strategy.SourceStrategy).Prefix("stiStrategy")...)
379
-		}
380
-
381
-	case strategy.Type == buildapi.DockerBuildStrategyType:
382
-		if strategy.DockerStrategy == nil {
383
-			allErrs = append(allErrs, fielderrors.NewFieldRequired("dockerStrategy"))
384
-		} else {
385
-			allErrs = append(allErrs, validateDockerStrategy(strategy.DockerStrategy).Prefix("dockerStrategy")...)
386
-		}
370
+	strategyCount := 0
371
+	if strategy.SourceStrategy != nil {
372
+		strategyCount++
373
+	}
374
+	if strategy.DockerStrategy != nil {
375
+		strategyCount++
376
+	}
377
+	if strategy.CustomStrategy != nil {
378
+		strategyCount++
379
+	}
380
+	if strategyCount != 1 {
381
+		return append(allErrs, fielderrors.NewFieldInvalid("", strategy, "must provide a value for exactly one of sourceStrategy, customStrategy, or dockerStrategy"))
382
+	}
387 383
 
388
-	case strategy.Type == buildapi.CustomBuildStrategyType:
389
-		if strategy.CustomStrategy == nil {
390
-			allErrs = append(allErrs, fielderrors.NewFieldRequired("customStrategy"))
391
-		} else {
392
-			allErrs = append(allErrs, validateCustomStrategy(strategy.CustomStrategy).Prefix("customStrategy")...)
393
-		}
394
-	default:
395
-		allErrs = append(allErrs, fielderrors.NewFieldInvalid("type", strategy.Type, "type is not in the enumerated list"))
384
+	if strategy.SourceStrategy != nil {
385
+		allErrs = append(allErrs, validateSourceStrategy(strategy.SourceStrategy).Prefix("sourceStrategy")...)
386
+	}
387
+	if strategy.DockerStrategy != nil {
388
+		allErrs = append(allErrs, validateDockerStrategy(strategy.DockerStrategy).Prefix("dockerStrategy")...)
389
+	}
390
+	if strategy.CustomStrategy != nil {
391
+		allErrs = append(allErrs, validateCustomStrategy(strategy.CustomStrategy).Prefix("customStrategy")...)
396 392
 	}
397 393
 
398 394
 	return allErrs
... ...
@@ -15,14 +15,12 @@ func TestBuildValidationSuccess(t *testing.T) {
15 15
 		ObjectMeta: kapi.ObjectMeta{Name: "buildid", Namespace: "default"},
16 16
 		Spec: buildapi.BuildSpec{
17 17
 			Source: buildapi.BuildSource{
18
-				Type: buildapi.BuildSourceGit,
19 18
 				Git: &buildapi.GitBuildSource{
20 19
 					URI: "http://github.com/my/repository",
21 20
 				},
22 21
 				ContextDir: "context",
23 22
 			},
24 23
 			Strategy: buildapi.BuildStrategy{
25
-				Type:           buildapi.DockerBuildStrategyType,
26 24
 				DockerStrategy: &buildapi.DockerBuildStrategy{},
27 25
 			},
28 26
 			Output: buildapi.BuildOutput{
... ...
@@ -46,14 +44,12 @@ func TestBuildValidationFailure(t *testing.T) {
46 46
 		ObjectMeta: kapi.ObjectMeta{Name: "", Namespace: ""},
47 47
 		Spec: buildapi.BuildSpec{
48 48
 			Source: buildapi.BuildSource{
49
-				Type: "Git123",
50 49
 				Git: &buildapi.GitBuildSource{
51 50
 					URI: "http://github.com/my/repository",
52 51
 				},
53 52
 				ContextDir: "context",
54 53
 			},
55 54
 			Strategy: buildapi.BuildStrategy{
56
-				Type:           buildapi.DockerBuildStrategyType,
57 55
 				DockerStrategy: &buildapi.DockerBuildStrategy{},
58 56
 			},
59 57
 			Output: buildapi.BuildOutput{
... ...
@@ -67,7 +63,7 @@ func TestBuildValidationFailure(t *testing.T) {
67 67
 			Phase: buildapi.BuildPhaseNew,
68 68
 		},
69 69
 	}
70
-	if result := ValidateBuild(build); len(result) != 3 {
70
+	if result := ValidateBuild(build); len(result) != 2 {
71 71
 		t.Errorf("Unexpected validation result: %v", result)
72 72
 	}
73 73
 }
... ...
@@ -75,14 +71,12 @@ func TestBuildValidationFailure(t *testing.T) {
75 75
 func newDefaultParameters() buildapi.BuildSpec {
76 76
 	return buildapi.BuildSpec{
77 77
 		Source: buildapi.BuildSource{
78
-			Type: buildapi.BuildSourceGit,
79 78
 			Git: &buildapi.GitBuildSource{
80 79
 				URI: "http://github.com/my/repository",
81 80
 			},
82 81
 			ContextDir: "context",
83 82
 		},
84 83
 		Strategy: buildapi.BuildStrategy{
85
-			Type:           buildapi.DockerBuildStrategyType,
86 84
 			DockerStrategy: &buildapi.DockerBuildStrategy{},
87 85
 		},
88 86
 		Output: buildapi.BuildOutput{
... ...
@@ -218,7 +212,6 @@ func TestBuildConfigGitSourceWithProxyFailure(t *testing.T) {
218 218
 		Spec: buildapi.BuildConfigSpec{
219 219
 			BuildSpec: buildapi.BuildSpec{
220 220
 				Source: buildapi.BuildSource{
221
-					Type: buildapi.BuildSourceGit,
222 221
 					Git: &buildapi.GitBuildSource{
223 222
 						URI:        "git://github.com/my/repository",
224 223
 						HTTPProxy:  "127.0.0.1:3128",
... ...
@@ -226,7 +219,6 @@ func TestBuildConfigGitSourceWithProxyFailure(t *testing.T) {
226 226
 					},
227 227
 				},
228 228
 				Strategy: buildapi.BuildStrategy{
229
-					Type:           buildapi.DockerBuildStrategyType,
230 229
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
231 230
 				},
232 231
 				Output: buildapi.BuildOutput{
... ...
@@ -260,14 +252,12 @@ func TestBuildConfigDockerStrategyImageChangeTrigger(t *testing.T) {
260 260
 		Spec: buildapi.BuildConfigSpec{
261 261
 			BuildSpec: buildapi.BuildSpec{
262 262
 				Source: buildapi.BuildSource{
263
-					Type: buildapi.BuildSourceGit,
264 263
 					Git: &buildapi.GitBuildSource{
265 264
 						URI: "http://github.com/my/repository",
266 265
 					},
267 266
 					ContextDir: "context",
268 267
 				},
269 268
 				Strategy: buildapi.BuildStrategy{
270
-					Type:           buildapi.DockerBuildStrategyType,
271 269
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
272 270
 				},
273 271
 				Output: buildapi.BuildOutput{
... ...
@@ -308,14 +298,12 @@ func TestBuildConfigValidationFailureRequiredName(t *testing.T) {
308 308
 		Spec: buildapi.BuildConfigSpec{
309 309
 			BuildSpec: buildapi.BuildSpec{
310 310
 				Source: buildapi.BuildSource{
311
-					Type: buildapi.BuildSourceGit,
312 311
 					Git: &buildapi.GitBuildSource{
313 312
 						URI: "http://github.com/my/repository",
314 313
 					},
315 314
 					ContextDir: "context",
316 315
 				},
317 316
 				Strategy: buildapi.BuildStrategy{
318
-					Type:           buildapi.DockerBuildStrategyType,
319 317
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
320 318
 				},
321 319
 				Output: buildapi.BuildOutput{
... ...
@@ -546,14 +534,12 @@ func TestBuildConfigImageChangeTriggers(t *testing.T) {
546 546
 			Spec: buildapi.BuildConfigSpec{
547 547
 				BuildSpec: buildapi.BuildSpec{
548 548
 					Source: buildapi.BuildSource{
549
-						Type: buildapi.BuildSourceGit,
550 549
 						Git: &buildapi.GitBuildSource{
551 550
 							URI: "http://github.com/my/repository",
552 551
 						},
553 552
 						ContextDir: "context",
554 553
 					},
555 554
 					Strategy: buildapi.BuildStrategy{
556
-						Type: buildapi.SourceBuildStrategyType,
557 555
 						SourceStrategy: &buildapi.SourceBuildStrategy{
558 556
 							From: kapi.ObjectReference{
559 557
 								Kind: "ImageStreamTag",
... ...
@@ -596,14 +582,12 @@ func TestBuildConfigValidationOutputFailure(t *testing.T) {
596 596
 		Spec: buildapi.BuildConfigSpec{
597 597
 			BuildSpec: buildapi.BuildSpec{
598 598
 				Source: buildapi.BuildSource{
599
-					Type: buildapi.BuildSourceGit,
600 599
 					Git: &buildapi.GitBuildSource{
601 600
 						URI: "http://github.com/my/repository",
602 601
 					},
603 602
 					ContextDir: "context",
604 603
 				},
605 604
 				Strategy: buildapi.BuildStrategy{
606
-					Type:           buildapi.DockerBuildStrategyType,
607 605
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
608 606
 				},
609 607
 				Output: buildapi.BuildOutput{
... ...
@@ -647,7 +631,6 @@ func TestValidateBuildRequest(t *testing.T) {
647 647
 
648 648
 func TestValidateSource(t *testing.T) {
649 649
 	dockerfile := "FROM something"
650
-	validGitURL := "https://github.com/some/server.git"
651 650
 	errorCases := []struct {
652 651
 		t        fielderrors.ValidationErrorType
653 652
 		path     string
... ...
@@ -655,124 +638,205 @@ func TestValidateSource(t *testing.T) {
655 655
 		ok       bool
656 656
 		multiple bool
657 657
 	}{
658
+		// 0
658 659
 		{
659 660
 			t:    fielderrors.ValidationErrorTypeRequired,
660 661
 			path: "git.uri",
661 662
 			source: &buildapi.BuildSource{
662
-				Type: buildapi.BuildSourceGit,
663 663
 				Git: &buildapi.GitBuildSource{
664 664
 					URI: "",
665 665
 				},
666 666
 			},
667 667
 		},
668
+		// 1
668 669
 		{
669 670
 			t:    fielderrors.ValidationErrorTypeInvalid,
670 671
 			path: "git.uri",
671 672
 			source: &buildapi.BuildSource{
672
-				Type: buildapi.BuildSourceGit,
673 673
 				Git: &buildapi.GitBuildSource{
674 674
 					URI: "::",
675 675
 				},
676 676
 			},
677 677
 		},
678
+		// 2
678 679
 		{
679 680
 			t:    fielderrors.ValidationErrorTypeInvalid,
680 681
 			path: "contextDir",
681 682
 			source: &buildapi.BuildSource{
682
-				Type:       buildapi.BuildSourceDockerfile,
683 683
 				Dockerfile: &dockerfile,
684 684
 				ContextDir: "../file",
685 685
 			},
686 686
 		},
687
-		{
688
-			t:    fielderrors.ValidationErrorTypeInvalid,
689
-			path: "git",
690
-			source: &buildapi.BuildSource{
691
-				Type:       buildapi.BuildSourceDockerfile,
692
-				Dockerfile: &dockerfile,
693
-				Git:        &buildapi.GitBuildSource{},
694
-				Binary:     &buildapi.BinaryBuildSource{},
695
-			},
696
-			multiple: true,
697
-		},
687
+		// 3
698 688
 		{
699 689
 			t:    fielderrors.ValidationErrorTypeInvalid,
700 690
 			path: "binary",
701 691
 			source: &buildapi.BuildSource{
702
-				Type: buildapi.BuildSourceGit,
703 692
 				Git: &buildapi.GitBuildSource{
704
-					URI: validGitURL,
693
+					URI: "https://example.com/repo.git",
705 694
 				},
706 695
 				Binary: &buildapi.BinaryBuildSource{},
707 696
 			},
708 697
 		},
698
+		// 4
709 699
 		{
710 700
 			t:    fielderrors.ValidationErrorTypeInvalid,
711
-			path: "git",
701
+			path: "binary.asFile",
712 702
 			source: &buildapi.BuildSource{
713
-				Type:   buildapi.BuildSourceBinary,
714
-				Git:    &buildapi.GitBuildSource{},
715
-				Binary: &buildapi.BinaryBuildSource{},
703
+				Binary: &buildapi.BinaryBuildSource{AsFile: "/a/path"},
716 704
 			},
717 705
 		},
706
+		// 5
718 707
 		{
719
-			t:    fielderrors.ValidationErrorTypeRequired,
720
-			path: "binary",
708
+			t:    fielderrors.ValidationErrorTypeInvalid,
709
+			path: "binary.asFile",
721 710
 			source: &buildapi.BuildSource{
722
-				Type: buildapi.BuildSourceBinary,
711
+				Binary: &buildapi.BinaryBuildSource{AsFile: "/"},
723 712
 			},
724 713
 		},
714
+		// 6
725 715
 		{
726 716
 			t:    fielderrors.ValidationErrorTypeInvalid,
727 717
 			path: "binary.asFile",
728 718
 			source: &buildapi.BuildSource{
729
-				Type:   buildapi.BuildSourceBinary,
730
-				Binary: &buildapi.BinaryBuildSource{AsFile: "/a/path"},
719
+				Binary: &buildapi.BinaryBuildSource{AsFile: "a\\b"},
731 720
 			},
732 721
 		},
722
+		// 7
733 723
 		{
734
-			t:    fielderrors.ValidationErrorTypeInvalid,
735
-			path: "binary.asFile",
736 724
 			source: &buildapi.BuildSource{
737
-				Type:   buildapi.BuildSourceBinary,
738
-				Binary: &buildapi.BinaryBuildSource{AsFile: "/"},
725
+				Binary: &buildapi.BinaryBuildSource{AsFile: "/././file"},
739 726
 			},
727
+			ok: true,
740 728
 		},
729
+		// 8
741 730
 		{
742
-			t:    fielderrors.ValidationErrorTypeInvalid,
743
-			path: "binary.asFile",
744 731
 			source: &buildapi.BuildSource{
745
-				Type:   buildapi.BuildSourceBinary,
746
-				Binary: &buildapi.BinaryBuildSource{AsFile: "a\\b"},
732
+				Binary:     &buildapi.BinaryBuildSource{AsFile: "/././file"},
733
+				Dockerfile: &dockerfile,
747 734
 			},
735
+			ok: true,
748 736
 		},
737
+		// 9
749 738
 		{
750
-			t:    fielderrors.ValidationErrorTypeInvalid,
751
-			path: "binary.asFile",
752 739
 			source: &buildapi.BuildSource{
753
-				Type:   buildapi.BuildSourceBinary,
754
-				Binary: &buildapi.BinaryBuildSource{AsFile: "/././file"},
740
+				Git: &buildapi.GitBuildSource{
741
+					URI: "https://example.com/repo.git",
742
+				},
743
+				Dockerfile: &dockerfile,
755 744
 			},
756 745
 			ok: true,
757 746
 		},
747
+		// 10
758 748
 		{
759
-			t:    fielderrors.ValidationErrorTypeInvalid,
760
-			path: "type",
761 749
 			source: &buildapi.BuildSource{
762
-				Type:   "invalidType",
763
-				Binary: &buildapi.BinaryBuildSource{AsFile: "/././file"},
750
+				Dockerfile: &dockerfile,
764 751
 			},
752
+			ok: true,
753
+		},
754
+		// 11
755
+		{
756
+			source: &buildapi.BuildSource{
757
+				Git: &buildapi.GitBuildSource{
758
+					URI: "https://example.com/repo.git",
759
+				},
760
+				ContextDir: "contextDir",
761
+			},
762
+			ok: true,
765 763
 		},
764
+		// 12
766 765
 		{
767 766
 			t:    fielderrors.ValidationErrorTypeRequired,
768
-			path: "type",
767
+			path: "sourceSecret.name",
769 768
 			source: &buildapi.BuildSource{
770
-				Binary: &buildapi.BinaryBuildSource{AsFile: "/././file"},
769
+				Git: &buildapi.GitBuildSource{
770
+					URI: "http://example.com/repo.git",
771
+				},
772
+				SourceSecret: &kapi.LocalObjectReference{},
773
+				ContextDir:   "contextDir/../somedir",
774
+			},
775
+		},
776
+		// 13
777
+		{
778
+			t:    fielderrors.ValidationErrorTypeInvalid,
779
+			path: "git.httpproxy",
780
+			source: &buildapi.BuildSource{
781
+				Git: &buildapi.GitBuildSource{
782
+					URI:       "https://example.com/repo.git",
783
+					HTTPProxy: "some!@#$%^&*()url",
784
+				},
785
+				ContextDir: "contextDir",
786
+			},
787
+		},
788
+		// 14
789
+		{
790
+			t:    fielderrors.ValidationErrorTypeInvalid,
791
+			path: "git.httpsproxy",
792
+			source: &buildapi.BuildSource{
793
+				Git: &buildapi.GitBuildSource{
794
+					URI:        "https://example.com/repo.git",
795
+					HTTPSProxy: "some!@#$%^&*()url",
796
+				},
797
+				ContextDir: "contextDir",
798
+			},
799
+		},
800
+	}
801
+	for i, tc := range errorCases {
802
+		errors := validateSource(tc.source, false)
803
+		switch len(errors) {
804
+		case 0:
805
+			if !tc.ok {
806
+				t.Errorf("%d: Unexpected validation result: %v", i, errors)
807
+			}
808
+			continue
809
+		case 1:
810
+			if tc.ok || tc.multiple {
811
+				t.Errorf("%d: Unexpected validation result: %v", i, errors)
812
+				continue
813
+			}
814
+		default:
815
+			if tc.ok || !tc.multiple {
816
+				t.Errorf("%d: Unexpected validation result: %v", i, errors)
817
+				continue
818
+			}
819
+		}
820
+		err := errors[0].(*fielderrors.ValidationError)
821
+		if err.Type != tc.t {
822
+			t.Errorf("%d: Unexpected error type: %s", i, err.Type)
823
+		}
824
+		if err.Field != tc.path {
825
+			t.Errorf("%d: Unexpected error path: %s", i, err.Field)
826
+		}
827
+	}
828
+
829
+	errorCases[11].source.ContextDir = "."
830
+	validateSource(errorCases[11].source, false)
831
+	if len(errorCases[11].source.ContextDir) != 0 {
832
+		t.Errorf("ContextDir was not cleaned: %s", errorCases[11].source.ContextDir)
833
+	}
834
+}
835
+
836
+func TestValidateStrategy(t *testing.T) {
837
+	errorCases := []struct {
838
+		t        fielderrors.ValidationErrorType
839
+		path     string
840
+		strategy *buildapi.BuildStrategy
841
+		ok       bool
842
+		multiple bool
843
+	}{
844
+		// 0
845
+		{
846
+			t:    fielderrors.ValidationErrorTypeInvalid,
847
+			path: "",
848
+			strategy: &buildapi.BuildStrategy{
849
+				SourceStrategy: &buildapi.SourceBuildStrategy{},
850
+				DockerStrategy: &buildapi.DockerBuildStrategy{},
851
+				CustomStrategy: &buildapi.CustomBuildStrategy{},
771 852
 			},
772 853
 		},
773 854
 	}
774 855
 	for i, tc := range errorCases {
775
-		errors := validateSource(tc.source)
856
+		errors := validateStrategy(tc.strategy)
776 857
 		switch len(errors) {
777 858
 		case 0:
778 859
 			if !tc.ok {
... ...
@@ -813,14 +877,12 @@ func TestValidateBuildSpec(t *testing.T) {
813 813
 			string(fielderrors.ValidationErrorTypeInvalid) + "output.to.name",
814 814
 			&buildapi.BuildSpec{
815 815
 				Source: buildapi.BuildSource{
816
-					Type: buildapi.BuildSourceGit,
817 816
 					Git: &buildapi.GitBuildSource{
818 817
 						URI: "http://github.com/my/repository",
819 818
 					},
820 819
 					ContextDir: "context",
821 820
 				},
822 821
 				Strategy: buildapi.BuildStrategy{
823
-					Type:           buildapi.DockerBuildStrategyType,
824 822
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
825 823
 				},
826 824
 				Output: buildapi.BuildOutput{
... ...
@@ -836,14 +898,12 @@ func TestValidateBuildSpec(t *testing.T) {
836 836
 			string(fielderrors.ValidationErrorTypeInvalid) + "output.to.kind",
837 837
 			&buildapi.BuildSpec{
838 838
 				Source: buildapi.BuildSource{
839
-					Type: buildapi.BuildSourceGit,
840 839
 					Git: &buildapi.GitBuildSource{
841 840
 						URI: "http://github.com/my/repository",
842 841
 					},
843 842
 					ContextDir: "context",
844 843
 				},
845 844
 				Strategy: buildapi.BuildStrategy{
846
-					Type:           buildapi.DockerBuildStrategyType,
847 845
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
848 846
 				},
849 847
 				Output: buildapi.BuildOutput{
... ...
@@ -859,14 +919,12 @@ func TestValidateBuildSpec(t *testing.T) {
859 859
 			string(fielderrors.ValidationErrorTypeRequired) + "output.to.kind",
860 860
 			&buildapi.BuildSpec{
861 861
 				Source: buildapi.BuildSource{
862
-					Type: buildapi.BuildSourceGit,
863 862
 					Git: &buildapi.GitBuildSource{
864 863
 						URI: "http://github.com/my/repository",
865 864
 					},
866 865
 					ContextDir: "context",
867 866
 				},
868 867
 				Strategy: buildapi.BuildStrategy{
869
-					Type:           buildapi.DockerBuildStrategyType,
870 868
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
871 869
 				},
872 870
 				Output: buildapi.BuildOutput{
... ...
@@ -879,14 +937,12 @@ func TestValidateBuildSpec(t *testing.T) {
879 879
 			string(fielderrors.ValidationErrorTypeRequired) + "output.to.name",
880 880
 			&buildapi.BuildSpec{
881 881
 				Source: buildapi.BuildSource{
882
-					Type: buildapi.BuildSourceGit,
883 882
 					Git: &buildapi.GitBuildSource{
884 883
 						URI: "http://github.com/my/repository",
885 884
 					},
886 885
 					ContextDir: "context",
887 886
 				},
888 887
 				Strategy: buildapi.BuildStrategy{
889
-					Type:           buildapi.DockerBuildStrategyType,
890 888
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
891 889
 				},
892 890
 				Output: buildapi.BuildOutput{
... ...
@@ -901,14 +957,12 @@ func TestValidateBuildSpec(t *testing.T) {
901 901
 			string(fielderrors.ValidationErrorTypeInvalid) + "output.to.name",
902 902
 			&buildapi.BuildSpec{
903 903
 				Source: buildapi.BuildSource{
904
-					Type: buildapi.BuildSourceGit,
905 904
 					Git: &buildapi.GitBuildSource{
906 905
 						URI: "http://github.com/my/repository",
907 906
 					},
908 907
 					ContextDir: "context",
909 908
 				},
910 909
 				Strategy: buildapi.BuildStrategy{
911
-					Type:           buildapi.DockerBuildStrategyType,
912 910
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
913 911
 				},
914 912
 				Output: buildapi.BuildOutput{
... ...
@@ -925,14 +979,12 @@ func TestValidateBuildSpec(t *testing.T) {
925 925
 			string(fielderrors.ValidationErrorTypeInvalid) + "output.to.namespace",
926 926
 			&buildapi.BuildSpec{
927 927
 				Source: buildapi.BuildSource{
928
-					Type: buildapi.BuildSourceGit,
929 928
 					Git: &buildapi.GitBuildSource{
930 929
 						URI: "http://github.com/my/repository",
931 930
 					},
932 931
 					ContextDir: "context",
933 932
 				},
934 933
 				Strategy: buildapi.BuildStrategy{
935
-					Type:           buildapi.DockerBuildStrategyType,
936 934
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
937 935
 				},
938 936
 				Output: buildapi.BuildOutput{
... ...
@@ -945,57 +997,17 @@ func TestValidateBuildSpec(t *testing.T) {
945 945
 			},
946 946
 		},
947 947
 		// 6
948
-		{
949
-			string(fielderrors.ValidationErrorTypeInvalid) + "strategy.type",
950
-			&buildapi.BuildSpec{
951
-				Source: buildapi.BuildSource{
952
-					Type: buildapi.BuildSourceGit,
953
-					Git: &buildapi.GitBuildSource{
954
-						URI: "http://github.com/my/repository",
955
-					},
956
-				},
957
-				Strategy: buildapi.BuildStrategy{Type: "invalid-type"},
958
-				Output: buildapi.BuildOutput{
959
-					To: &kapi.ObjectReference{
960
-						Kind: "DockerImage",
961
-						Name: "repository/data",
962
-					},
963
-				},
964
-			},
965
-		},
966
-		// 7
967
-		{
968
-			string(fielderrors.ValidationErrorTypeRequired) + "strategy.type",
969
-			&buildapi.BuildSpec{
970
-				Source: buildapi.BuildSource{
971
-					Type: buildapi.BuildSourceGit,
972
-					Git: &buildapi.GitBuildSource{
973
-						URI: "http://github.com/my/repository",
974
-					},
975
-				},
976
-				Strategy: buildapi.BuildStrategy{},
977
-				Output: buildapi.BuildOutput{
978
-					To: &kapi.ObjectReference{
979
-						Kind: "DockerImage",
980
-						Name: "repository/data",
981
-					},
982
-				},
983
-			},
984
-		},
985
-		// 8
986 948
 		// invalid because from is not specified in the
987 949
 		// sti strategy definition
988 950
 		{
989
-			string(fielderrors.ValidationErrorTypeRequired) + "strategy.stiStrategy.from.kind",
951
+			string(fielderrors.ValidationErrorTypeRequired) + "strategy.sourceStrategy.from.kind",
990 952
 			&buildapi.BuildSpec{
991 953
 				Source: buildapi.BuildSource{
992
-					Type: buildapi.BuildSourceGit,
993 954
 					Git: &buildapi.GitBuildSource{
994 955
 						URI: "http://github.com/my/repository",
995 956
 					},
996 957
 				},
997 958
 				Strategy: buildapi.BuildStrategy{
998
-					Type:           buildapi.SourceBuildStrategyType,
999 959
 					SourceStrategy: &buildapi.SourceBuildStrategy{},
1000 960
 				},
1001 961
 				Output: buildapi.BuildOutput{
... ...
@@ -1006,19 +1018,17 @@ func TestValidateBuildSpec(t *testing.T) {
1006 1006
 				},
1007 1007
 			},
1008 1008
 		},
1009
-		// 9
1009
+		// 7
1010 1010
 		// Invalid because from.name is not specified
1011 1011
 		{
1012
-			string(fielderrors.ValidationErrorTypeRequired) + "strategy.stiStrategy.from.name",
1012
+			string(fielderrors.ValidationErrorTypeRequired) + "strategy.sourceStrategy.from.name",
1013 1013
 			&buildapi.BuildSpec{
1014 1014
 				Source: buildapi.BuildSource{
1015
-					Type: buildapi.BuildSourceGit,
1016 1015
 					Git: &buildapi.GitBuildSource{
1017 1016
 						URI: "http://github.com/my/repository",
1018 1017
 					},
1019 1018
 				},
1020 1019
 				Strategy: buildapi.BuildStrategy{
1021
-					Type: buildapi.SourceBuildStrategyType,
1022 1020
 					SourceStrategy: &buildapi.SourceBuildStrategy{
1023 1021
 						From: kapi.ObjectReference{
1024 1022
 							Kind: "DockerImage",
... ...
@@ -1033,19 +1043,17 @@ func TestValidateBuildSpec(t *testing.T) {
1033 1033
 				},
1034 1034
 			},
1035 1035
 		},
1036
-		// 10
1036
+		// 8
1037 1037
 		// invalid because from name is a bad format
1038 1038
 		{
1039
-			string(fielderrors.ValidationErrorTypeInvalid) + "strategy.stiStrategy.from.name",
1039
+			string(fielderrors.ValidationErrorTypeInvalid) + "strategy.sourceStrategy.from.name",
1040 1040
 			&buildapi.BuildSpec{
1041 1041
 				Source: buildapi.BuildSource{
1042
-					Type: buildapi.BuildSourceGit,
1043 1042
 					Git: &buildapi.GitBuildSource{
1044 1043
 						URI: "http://github.com/my/repository",
1045 1044
 					},
1046 1045
 				},
1047 1046
 				Strategy: buildapi.BuildStrategy{
1048
-					Type: buildapi.SourceBuildStrategyType,
1049 1047
 					SourceStrategy: &buildapi.SourceBuildStrategy{
1050 1048
 						From: kapi.ObjectReference{Kind: "ImageStreamTag", Name: "bad format"},
1051 1049
 					},
... ...
@@ -1058,20 +1066,18 @@ func TestValidateBuildSpec(t *testing.T) {
1058 1058
 				},
1059 1059
 			},
1060 1060
 		},
1061
-		// 11
1061
+		// 9
1062 1062
 		// invalid because from is not specified in the
1063 1063
 		// custom strategy definition
1064 1064
 		{
1065 1065
 			string(fielderrors.ValidationErrorTypeRequired) + "strategy.customStrategy.from.kind",
1066 1066
 			&buildapi.BuildSpec{
1067 1067
 				Source: buildapi.BuildSource{
1068
-					Type: buildapi.BuildSourceGit,
1069 1068
 					Git: &buildapi.GitBuildSource{
1070 1069
 						URI: "http://github.com/my/repository",
1071 1070
 					},
1072 1071
 				},
1073 1072
 				Strategy: buildapi.BuildStrategy{
1074
-					Type:           buildapi.CustomBuildStrategyType,
1075 1073
 					CustomStrategy: &buildapi.CustomBuildStrategy{},
1076 1074
 				},
1077 1075
 				Output: buildapi.BuildOutput{
... ...
@@ -1082,20 +1088,18 @@ func TestValidateBuildSpec(t *testing.T) {
1082 1082
 				},
1083 1083
 			},
1084 1084
 		},
1085
-		// 12
1085
+		// 10
1086 1086
 		// invalid because from.name is not specified in the
1087 1087
 		// custom strategy definition
1088 1088
 		{
1089 1089
 			string(fielderrors.ValidationErrorTypeInvalid) + "strategy.customStrategy.from.name",
1090 1090
 			&buildapi.BuildSpec{
1091 1091
 				Source: buildapi.BuildSource{
1092
-					Type: buildapi.BuildSourceGit,
1093 1092
 					Git: &buildapi.GitBuildSource{
1094 1093
 						URI: "http://github.com/my/repository",
1095 1094
 					},
1096 1095
 				},
1097 1096
 				Strategy: buildapi.BuildStrategy{
1098
-					Type: buildapi.CustomBuildStrategyType,
1099 1097
 					CustomStrategy: &buildapi.CustomBuildStrategy{
1100 1098
 						From: kapi.ObjectReference{Kind: "ImageStreamTag", Name: "bad format"},
1101 1099
 					},
... ...
@@ -1108,51 +1112,45 @@ func TestValidateBuildSpec(t *testing.T) {
1108 1108
 				},
1109 1109
 			},
1110 1110
 		},
1111
-		// 13
1111
+		// 11
1112 1112
 		{
1113 1113
 			string(fielderrors.ValidationErrorTypeInvalid) + "source.dockerfile",
1114 1114
 			&buildapi.BuildSpec{
1115 1115
 				Source: buildapi.BuildSource{
1116
-					Type:       buildapi.BuildSourceDockerfile,
1117 1116
 					Dockerfile: &longString,
1118 1117
 				},
1119 1118
 				Strategy: buildapi.BuildStrategy{
1120
-					Type:           buildapi.DockerBuildStrategyType,
1121 1119
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
1122 1120
 				},
1123 1121
 			},
1124 1122
 		},
1125
-		// 14
1123
+		// 12
1126 1124
 		{
1127 1125
 			string(fielderrors.ValidationErrorTypeInvalid) + "source.dockerfile",
1128 1126
 			&buildapi.BuildSpec{
1129 1127
 				Source: buildapi.BuildSource{
1130
-					Type:       buildapi.BuildSourceGit,
1131 1128
 					Dockerfile: &longString,
1132 1129
 					Git: &buildapi.GitBuildSource{
1133 1130
 						URI: "http://github.com/my/repository",
1134 1131
 					},
1135 1132
 				},
1136 1133
 				Strategy: buildapi.BuildStrategy{
1137
-					Type:           buildapi.DockerBuildStrategyType,
1138 1134
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
1139 1135
 				},
1140 1136
 			},
1141 1137
 		},
1142
-		// 15
1138
+		// 13
1143 1139
 		// invalid because CompletionDeadlineSeconds <= 0
1144 1140
 		{
1145 1141
 			string(fielderrors.ValidationErrorTypeInvalid) + "completionDeadlineSeconds",
1146 1142
 			&buildapi.BuildSpec{
1147 1143
 				Source: buildapi.BuildSource{
1148
-					Type: buildapi.BuildSourceGit,
1149 1144
 					Git: &buildapi.GitBuildSource{
1150 1145
 						URI: "http://github.com/my/repository",
1151 1146
 					},
1152 1147
 					ContextDir: "context",
1153 1148
 				},
1154 1149
 				Strategy: buildapi.BuildStrategy{
1155
-					Type:           buildapi.DockerBuildStrategyType,
1156 1150
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
1157 1151
 				},
1158 1152
 				Output: buildapi.BuildOutput{
... ...
@@ -1164,7 +1162,23 @@ func TestValidateBuildSpec(t *testing.T) {
1164 1164
 				CompletionDeadlineSeconds: &zero,
1165 1165
 			},
1166 1166
 		},
1167
-	}
1167
+		// 14
1168
+		// must provide some source input
1169
+		{
1170
+			string(fielderrors.ValidationErrorTypeInvalid) + "source",
1171
+			&buildapi.BuildSpec{
1172
+				Source: buildapi.BuildSource{},
1173
+				Strategy: buildapi.BuildStrategy{
1174
+					DockerStrategy: &buildapi.DockerBuildStrategy{},
1175
+				},
1176
+				Output: buildapi.BuildOutput{
1177
+					To: &kapi.ObjectReference{
1178
+						Kind: "DockerImage",
1179
+						Name: "repository/data",
1180
+					},
1181
+				},
1182
+			},
1183
+		}}
1168 1184
 
1169 1185
 	for count, config := range errorCases {
1170 1186
 		errors := validateBuildSpec(config.BuildSpec)
... ...
@@ -1189,13 +1203,11 @@ func TestValidateBuildSpecSuccess(t *testing.T) {
1189 1189
 		{
1190 1190
 			&buildapi.BuildSpec{
1191 1191
 				Source: buildapi.BuildSource{
1192
-					Type: buildapi.BuildSourceGit,
1193 1192
 					Git: &buildapi.GitBuildSource{
1194 1193
 						URI: "http://github.com/my/repository",
1195 1194
 					},
1196 1195
 				},
1197 1196
 				Strategy: buildapi.BuildStrategy{
1198
-					Type: buildapi.SourceBuildStrategyType,
1199 1197
 					SourceStrategy: &buildapi.SourceBuildStrategy{
1200 1198
 						From: kapi.ObjectReference{
1201 1199
 							Kind: "DockerImage",
... ...
@@ -1215,13 +1227,11 @@ func TestValidateBuildSpecSuccess(t *testing.T) {
1215 1215
 		{
1216 1216
 			&buildapi.BuildSpec{
1217 1217
 				Source: buildapi.BuildSource{
1218
-					Type: buildapi.BuildSourceGit,
1219 1218
 					Git: &buildapi.GitBuildSource{
1220 1219
 						URI: "http://github.com/my/repository",
1221 1220
 					},
1222 1221
 				},
1223 1222
 				Strategy: buildapi.BuildStrategy{
1224
-					Type: buildapi.CustomBuildStrategyType,
1225 1223
 					CustomStrategy: &buildapi.CustomBuildStrategy{
1226 1224
 						From: kapi.ObjectReference{
1227 1225
 							Kind: "ImageStreamTag",
... ...
@@ -1241,13 +1251,11 @@ func TestValidateBuildSpecSuccess(t *testing.T) {
1241 1241
 		{
1242 1242
 			&buildapi.BuildSpec{
1243 1243
 				Source: buildapi.BuildSource{
1244
-					Type: buildapi.BuildSourceGit,
1245 1244
 					Git: &buildapi.GitBuildSource{
1246 1245
 						URI: "http://github.com/my/repository",
1247 1246
 					},
1248 1247
 				},
1249 1248
 				Strategy: buildapi.BuildStrategy{
1250
-					Type:           buildapi.DockerBuildStrategyType,
1251 1249
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
1252 1250
 				},
1253 1251
 				Output: buildapi.BuildOutput{
... ...
@@ -1262,13 +1270,11 @@ func TestValidateBuildSpecSuccess(t *testing.T) {
1262 1262
 		{
1263 1263
 			&buildapi.BuildSpec{
1264 1264
 				Source: buildapi.BuildSource{
1265
-					Type: buildapi.BuildSourceGit,
1266 1265
 					Git: &buildapi.GitBuildSource{
1267 1266
 						URI: "http://github.com/my/repository",
1268 1267
 					},
1269 1268
 				},
1270 1269
 				Strategy: buildapi.BuildStrategy{
1271
-					Type: buildapi.DockerBuildStrategyType,
1272 1270
 					DockerStrategy: &buildapi.DockerBuildStrategy{
1273 1271
 						From: &kapi.ObjectReference{
1274 1272
 							Kind: "ImageStreamImage",
... ...
@@ -1288,14 +1294,12 @@ func TestValidateBuildSpecSuccess(t *testing.T) {
1288 1288
 		{
1289 1289
 			&buildapi.BuildSpec{
1290 1290
 				Source: buildapi.BuildSource{
1291
-					Type:       buildapi.BuildSourceDockerfile,
1292 1291
 					Dockerfile: &shortString,
1293 1292
 					Git: &buildapi.GitBuildSource{
1294 1293
 						URI: "http://github.com/my/repository",
1295 1294
 					},
1296 1295
 				},
1297 1296
 				Strategy: buildapi.BuildStrategy{
1298
-					Type: buildapi.DockerBuildStrategyType,
1299 1297
 					DockerStrategy: &buildapi.DockerBuildStrategy{
1300 1298
 						From: &kapi.ObjectReference{
1301 1299
 							Kind: "ImageStreamImage",
... ...
@@ -1440,3 +1444,22 @@ func TestValidateTrigger(t *testing.T) {
1440 1440
 		}
1441 1441
 	}
1442 1442
 }
1443
+
1444
+func TestValidateToImageReference(t *testing.T) {
1445
+	o := &kapi.ObjectReference{
1446
+		Name:      "somename",
1447
+		Namespace: "somenamespace",
1448
+		Kind:      "DockerImage",
1449
+	}
1450
+	errs := validateToImageReference(o)
1451
+	if len(errs) != 1 {
1452
+		t.Errorf("Wrong number of errors: %v", errs)
1453
+	}
1454
+	err := errs[0].(*fielderrors.ValidationError)
1455
+	if err.Type != fielderrors.ValidationErrorTypeInvalid {
1456
+		t.Errorf("Wrong error type, expected %v, got %v", fielderrors.ValidationErrorTypeInvalid, err.Type)
1457
+	}
1458
+	if err.Field != "namespace" {
1459
+		t.Errorf("Error on wrong field, expected %s, got %s", "namespace", err.Field)
1460
+	}
1461
+}
... ...
@@ -38,7 +38,7 @@ func buildInfo(build *api.Build) []KeyValue {
38 38
 			kv = append(kv, KeyValue{"OPENSHIFT_BUILD_COMMIT", build.Spec.Revision.Git.Commit})
39 39
 		}
40 40
 	}
41
-	if build.Spec.Strategy.Type == api.SourceBuildStrategyType {
41
+	if build.Spec.Strategy.SourceStrategy != nil {
42 42
 		env := build.Spec.Strategy.SourceStrategy.Env
43 43
 		for _, e := range env {
44 44
 			kv = append(kv, KeyValue{e.Name, e.Value})
... ...
@@ -96,7 +96,6 @@ func updateBuildRevision(c client.BuildInterface, build *api.Build, sourceInfo *
96 96
 		return
97 97
 	}
98 98
 	build.Spec.Revision = &api.SourceRevision{
99
-		Type: api.BuildSourceGit,
100 99
 		Git: &api.GitSourceRevision{
101 100
 			Commit:  sourceInfo.CommitID,
102 101
 			Message: sourceInfo.Message,
... ...
@@ -23,7 +23,6 @@ func TestBuildInfo(t *testing.T) {
23 23
 				},
24 24
 			},
25 25
 			Strategy: api.BuildStrategy{
26
-				Type: api.SourceBuildStrategyType,
27 26
 				SourceStrategy: &api.SourceBuildStrategy{
28 27
 					Env: []kapi.EnvVar{
29 28
 						{Name: "RAILS_ENV", Value: "production"},
... ...
@@ -89,12 +89,10 @@ func makeBuild() *api.Build {
89 89
 	return &api.Build{
90 90
 		Spec: api.BuildSpec{
91 91
 			Source: api.BuildSource{
92
-				Type: api.BuildSourceGit,
93 92
 				Git: &api.GitBuildSource{
94 93
 					URI: "http://localhost/123",
95 94
 				}},
96 95
 			Strategy: api.BuildStrategy{
97
-				Type: api.SourceBuildStrategyType,
98 96
 				SourceStrategy: &api.SourceBuildStrategy{
99 97
 					From: kapi.ObjectReference{
100 98
 						Kind: "DockerImage",
... ...
@@ -82,7 +82,6 @@ func (i *testInstantiator) Instantiate(namespace string, request *buildapi.Build
82 82
 func baseBuildConfig() *buildapi.BuildConfig {
83 83
 	bc := &buildapi.BuildConfig{}
84 84
 	bc.Name = "testBuildConfig"
85
-	bc.Spec.BuildSpec.Strategy.Type = buildapi.SourceBuildStrategyType
86 85
 	bc.Spec.BuildSpec.Strategy.SourceStrategy = &buildapi.SourceBuildStrategy{}
87 86
 	bc.Spec.BuildSpec.Strategy.SourceStrategy.From.Name = "builderimage:latest"
88 87
 	bc.Spec.BuildSpec.Strategy.SourceStrategy.From.Kind = "ImageStreamTag"
... ...
@@ -153,7 +153,7 @@ func (bc *BuildController) nextBuildPhase(build *buildapi.Build) error {
153 153
 	podSpec, err := bc.BuildStrategy.CreateBuildPod(buildCopy)
154 154
 	if err != nil {
155 155
 		build.Status.Reason = buildapi.StatusReasonCannotCreateBuildPodSpec
156
-		return fmt.Errorf("failed to create a build pod spec with strategy %q: %v", build.Spec.Strategy.Type, err)
156
+		return fmt.Errorf("failed to create a build pod spec for build %s/%s: %v", build.Namespace, build.Name, err)
157 157
 	}
158 158
 	glog.V(4).Infof("Pod %s for build %s/%s is about to be created", podSpec.Name, build.Namespace, build.Name)
159 159
 
... ...
@@ -119,14 +119,12 @@ func mockBuild(phase buildapi.BuildPhase, output buildapi.BuildOutput) *buildapi
119 119
 		},
120 120
 		Spec: buildapi.BuildSpec{
121 121
 			Source: buildapi.BuildSource{
122
-				Type: buildapi.BuildSourceGit,
123 122
 				Git: &buildapi.GitBuildSource{
124 123
 					URI: "http://my.build.com/the/build/Dockerfile",
125 124
 				},
126 125
 				ContextDir: "contextimage",
127 126
 			},
128 127
 			Strategy: buildapi.BuildStrategy{
129
-				Type:           buildapi.DockerBuildStrategyType,
130 128
 				DockerStrategy: &buildapi.DockerBuildStrategy{},
131 129
 			},
132 130
 			Output: output,
... ...
@@ -335,16 +335,17 @@ type typeBasedFactoryStrategy struct {
335 335
 func (f *typeBasedFactoryStrategy) CreateBuildPod(build *buildapi.Build) (*kapi.Pod, error) {
336 336
 	var pod *kapi.Pod
337 337
 	var err error
338
-	switch build.Spec.Strategy.Type {
339
-	case buildapi.DockerBuildStrategyType:
338
+	switch {
339
+	case build.Spec.Strategy.DockerStrategy != nil:
340 340
 		pod, err = f.DockerBuildStrategy.CreateBuildPod(build)
341
-	case buildapi.SourceBuildStrategyType:
341
+	case build.Spec.Strategy.SourceStrategy != nil:
342 342
 		pod, err = f.SourceBuildStrategy.CreateBuildPod(build)
343
-	case buildapi.CustomBuildStrategyType:
343
+	case build.Spec.Strategy.CustomStrategy != nil:
344 344
 		pod, err = f.CustomBuildStrategy.CreateBuildPod(build)
345 345
 	default:
346
-		return nil, fmt.Errorf("no supported build strategy defined for Build %s/%s with type %s", build.Namespace, build.Name, build.Spec.Strategy.Type)
346
+		return nil, fmt.Errorf("no supported build strategy defined for Build %s/%s", build.Namespace, build.Name)
347 347
 	}
348
+
348 349
 	if pod != nil {
349 350
 		if pod.Annotations == nil {
350 351
 			pod.Annotations = map[string]string{}
... ...
@@ -309,7 +309,6 @@ func mockBuildConfig(baseImage, triggerImage, repoName, repoTag string) *buildap
309 309
 		Spec: buildapi.BuildConfigSpec{
310 310
 			BuildSpec: buildapi.BuildSpec{
311 311
 				Strategy: buildapi.BuildStrategy{
312
-					Type: buildapi.DockerBuildStrategyType,
313 312
 					DockerStrategy: &buildapi.DockerBuildStrategy{
314 313
 						From: &kapi.ObjectReference{
315 314
 							Kind: "ImageStreamTag",
... ...
@@ -118,7 +118,6 @@ func mockCustomBuild(forcePull bool) *buildapi.Build {
118 118
 				Git: &buildapi.GitSourceRevision{},
119 119
 			},
120 120
 			Source: buildapi.BuildSource{
121
-				Type: buildapi.BuildSourceGit,
122 121
 				Git: &buildapi.GitBuildSource{
123 122
 					URI: "http://my.build.com/the/dockerbuild/Dockerfile",
124 123
 					Ref: "master",
... ...
@@ -127,7 +126,6 @@ func mockCustomBuild(forcePull bool) *buildapi.Build {
127 127
 				SourceSecret: &kapi.LocalObjectReference{Name: "secretFoo"},
128 128
 			},
129 129
 			Strategy: buildapi.BuildStrategy{
130
-				Type: buildapi.CustomBuildStrategyType,
131 130
 				CustomStrategy: &buildapi.CustomBuildStrategy{
132 131
 					From: kapi.ObjectReference{
133 132
 						Kind: "DockerImage",
... ...
@@ -113,7 +113,6 @@ func mockDockerBuild() *buildapi.Build {
113 113
 				SourceSecret: &kapi.LocalObjectReference{Name: "secretFoo"},
114 114
 			},
115 115
 			Strategy: buildapi.BuildStrategy{
116
-				Type: buildapi.DockerBuildStrategyType,
117 116
 				DockerStrategy: &buildapi.DockerBuildStrategy{
118 117
 					PullSecret: &kapi.LocalObjectReference{Name: "bar"},
119 118
 					Env: []kapi.EnvVar{
... ...
@@ -161,7 +161,6 @@ func mockSTIBuild() *buildapi.Build {
161 161
 				SourceSecret: &kapi.LocalObjectReference{Name: "fooSecret"},
162 162
 			},
163 163
 			Strategy: buildapi.BuildStrategy{
164
-				Type: buildapi.SourceBuildStrategyType,
165 164
 				SourceStrategy: &buildapi.SourceBuildStrategy{
166 165
 					From: kapi.ObjectReference{
167 166
 						Kind: "DockerImage",
... ...
@@ -49,8 +49,8 @@ func setupDockerSocket(podSpec *kapi.Pod) {
49 49
 func setupBuildEnv(build *buildapi.Build, pod *kapi.Pod) error {
50 50
 	vars := []kapi.EnvVar{}
51 51
 
52
-	switch build.Spec.Source.Type {
53
-	case buildapi.BuildSourceGit:
52
+	switch {
53
+	case build.Spec.Source.Git != nil:
54 54
 		vars = append(vars, kapi.EnvVar{Name: "SOURCE_URI", Value: build.Spec.Source.Git.URI})
55 55
 		vars = append(vars, kapi.EnvVar{Name: "SOURCE_REF", Value: build.Spec.Source.Git.Ref})
56 56
 	default:
... ...
@@ -164,14 +164,16 @@ func describeBuildRequest(request *buildapi.BuildRequest) string {
164 164
 // This will replace the existing variable definitions with provided env
165 165
 func updateBuildEnv(strategy *buildapi.BuildStrategy, env []kapi.EnvVar) {
166 166
 	var buildEnv *[]kapi.EnvVar
167
-	switch strategy.Type {
168
-	case buildapi.SourceBuildStrategyType:
167
+
168
+	switch {
169
+	case strategy.SourceStrategy != nil:
170
+		buildEnv = &strategy.SourceStrategy.Env
171
+	case strategy.DockerStrategy != nil:
172
+		buildEnv = &strategy.SourceStrategy.Env
173
+	case strategy.CustomStrategy != nil:
169 174
 		buildEnv = &strategy.SourceStrategy.Env
170
-	case buildapi.DockerBuildStrategyType:
171
-		buildEnv = &strategy.DockerStrategy.Env
172
-	case buildapi.CustomBuildStrategyType:
173
-		buildEnv = &strategy.CustomStrategy.Env
174 175
 	}
176
+
175 177
 	newEnv := []kapi.EnvVar{}
176 178
 	for _, e := range *buildEnv {
177 179
 		exists := false
... ...
@@ -370,7 +372,6 @@ func (g *BuildGenerator) generateBuildFromConfig(ctx kapi.Context, bc *buildapi.
370 370
 	if binary != nil {
371 371
 		build.Spec.Source.Git = nil
372 372
 		build.Spec.Source.Binary = binary
373
-		build.Spec.Source.Type = buildapi.BuildSourceBinary
374 373
 		if build.Spec.Source.Dockerfile != nil && binary.AsFile == "Dockerfile" {
375 374
 			build.Spec.Source.Dockerfile = nil
376 375
 		}
... ...
@@ -404,7 +405,7 @@ func (g *BuildGenerator) generateBuildFromConfig(ctx kapi.Context, bc *buildapi.
404 404
 		image = strategyImageChangeTrigger.LastTriggeredImageID
405 405
 	}
406 406
 	switch {
407
-	case build.Spec.Strategy.Type == buildapi.SourceBuildStrategyType:
407
+	case build.Spec.Strategy.SourceStrategy != nil:
408 408
 		if image == "" {
409 409
 			image, err = g.resolveImageStreamReference(ctx, build.Spec.Strategy.SourceStrategy.From, build.Status.Config.Namespace)
410 410
 			if err != nil {
... ...
@@ -418,7 +419,7 @@ func (g *BuildGenerator) generateBuildFromConfig(ctx kapi.Context, bc *buildapi.
418 418
 		if build.Spec.Strategy.SourceStrategy.PullSecret == nil {
419 419
 			build.Spec.Strategy.SourceStrategy.PullSecret = g.resolveImageSecret(ctx, builderSecrets, &build.Spec.Strategy.SourceStrategy.From, bc.Namespace)
420 420
 		}
421
-	case build.Spec.Strategy.Type == buildapi.DockerBuildStrategyType &&
421
+	case build.Spec.Strategy.DockerStrategy != nil &&
422 422
 		build.Spec.Strategy.DockerStrategy.From != nil:
423 423
 		if image == "" {
424 424
 			image, err = g.resolveImageStreamReference(ctx, *build.Spec.Strategy.DockerStrategy.From, build.Status.Config.Namespace)
... ...
@@ -433,7 +434,7 @@ func (g *BuildGenerator) generateBuildFromConfig(ctx kapi.Context, bc *buildapi.
433 433
 		if build.Spec.Strategy.DockerStrategy.PullSecret == nil {
434 434
 			build.Spec.Strategy.DockerStrategy.PullSecret = g.resolveImageSecret(ctx, builderSecrets, build.Spec.Strategy.DockerStrategy.From, bc.Namespace)
435 435
 		}
436
-	case build.Spec.Strategy.Type == buildapi.CustomBuildStrategyType:
436
+	case build.Spec.Strategy.CustomStrategy != nil:
437 437
 		if image == "" {
438 438
 			image, err = g.resolveImageStreamReference(ctx, build.Spec.Strategy.CustomStrategy.From, build.Status.Config.Namespace)
439 439
 			if err != nil {
... ...
@@ -211,7 +211,6 @@ func TestInstantiateWithImageTrigger(t *testing.T) {
211 211
 			Spec: buildapi.BuildConfigSpec{
212 212
 				BuildSpec: buildapi.BuildSpec{
213 213
 					Strategy: buildapi.BuildStrategy{
214
-						Type: buildapi.SourceBuildStrategyType,
215 214
 						SourceStrategy: &buildapi.SourceBuildStrategy{
216 215
 							From: kapi.ObjectReference{
217 216
 								Name: "image3:tag3",
... ...
@@ -340,7 +339,6 @@ func TestFindImageTrigger(t *testing.T) {
340 340
 		Spec: buildapi.BuildConfigSpec{
341 341
 			BuildSpec: buildapi.BuildSpec{
342 342
 				Strategy: buildapi.BuildStrategy{
343
-					Type: buildapi.SourceBuildStrategyType,
344 343
 					SourceStrategy: &buildapi.SourceBuildStrategy{
345 344
 						From: kapi.ObjectReference{
346 345
 							Name: "image3:tag3",
... ...
@@ -550,7 +548,6 @@ func TestGenerateBuildFromConfig(t *testing.T) {
550 550
 			BuildSpec: buildapi.BuildSpec{
551 551
 				Source: source,
552 552
 				Revision: &buildapi.SourceRevision{
553
-					Type: buildapi.BuildSourceGit,
554 553
 					Git: &buildapi.GitSourceRevision{
555 554
 						Commit: "1234",
556 555
 					},
... ...
@@ -565,7 +562,6 @@ func TestGenerateBuildFromConfig(t *testing.T) {
565 565
 		},
566 566
 	}
567 567
 	revision := &buildapi.SourceRevision{
568
-		Type: buildapi.BuildSourceGit,
569 568
 		Git: &buildapi.GitSourceRevision{
570 569
 			Commit: "abcd",
571 570
 		},
... ...
@@ -624,7 +620,6 @@ func TestGenerateBuildWithImageTagForSourceStrategyImageRepository(t *testing.T)
624 624
 			BuildSpec: buildapi.BuildSpec{
625 625
 				Source: source,
626 626
 				Revision: &buildapi.SourceRevision{
627
-					Type: buildapi.BuildSourceGit,
628 627
 					Git: &buildapi.GitSourceRevision{
629 628
 						Commit: "1234",
630 629
 					},
... ...
@@ -703,7 +698,6 @@ func TestGenerateBuildWithImageTagForDockerStrategyImageRepository(t *testing.T)
703 703
 			BuildSpec: buildapi.BuildSpec{
704 704
 				Source: source,
705 705
 				Revision: &buildapi.SourceRevision{
706
-					Type: buildapi.BuildSourceGit,
707 706
 					Git: &buildapi.GitSourceRevision{
708 707
 						Commit: "1234",
709 708
 					},
... ...
@@ -781,7 +775,6 @@ func TestGenerateBuildWithImageTagForCustomStrategyImageRepository(t *testing.T)
781 781
 			BuildSpec: buildapi.BuildSpec{
782 782
 				Source: source,
783 783
 				Revision: &buildapi.SourceRevision{
784
-					Type: buildapi.BuildSourceGit,
785 784
 					Git: &buildapi.GitSourceRevision{
786 785
 						Commit: "1234",
787 786
 					},
... ...
@@ -858,7 +851,6 @@ func TestGenerateBuildFromBuild(t *testing.T) {
858 858
 		Spec: buildapi.BuildSpec{
859 859
 			Source: source,
860 860
 			Revision: &buildapi.SourceRevision{
861
-				Type: buildapi.BuildSourceGit,
862 861
 				Git: &buildapi.GitSourceRevision{
863 862
 					Commit: "1234",
864 863
 				},
... ...
@@ -891,7 +883,6 @@ func TestGenerateBuildFromBuildWithBuildConfig(t *testing.T) {
891 891
 		Spec: buildapi.BuildSpec{
892 892
 			Source: source,
893 893
 			Revision: &buildapi.SourceRevision{
894
-				Type: buildapi.BuildSourceGit,
895 894
 				Git: &buildapi.GitSourceRevision{
896 895
 					Commit: "1234",
897 896
 				},
... ...
@@ -907,7 +898,6 @@ func TestGenerateBuildFromBuildWithBuildConfig(t *testing.T) {
907 907
 		Spec: buildapi.BuildSpec{
908 908
 			Source: source,
909 909
 			Revision: &buildapi.SourceRevision{
910
-				Type: buildapi.BuildSourceGit,
911 910
 				Git: &buildapi.GitSourceRevision{
912 911
 					Commit: "1234",
913 912
 				},
... ...
@@ -1228,7 +1218,6 @@ func mockResources() kapi.ResourceRequirements {
1228 1228
 
1229 1229
 func mockDockerStrategyForNilImage() buildapi.BuildStrategy {
1230 1230
 	return buildapi.BuildStrategy{
1231
-		Type: buildapi.DockerBuildStrategyType,
1232 1231
 		DockerStrategy: &buildapi.DockerBuildStrategy{
1233 1232
 			NoCache: true,
1234 1233
 		},
... ...
@@ -1237,7 +1226,6 @@ func mockDockerStrategyForNilImage() buildapi.BuildStrategy {
1237 1237
 
1238 1238
 func mockDockerStrategyForDockerImage(name string) buildapi.BuildStrategy {
1239 1239
 	return buildapi.BuildStrategy{
1240
-		Type: buildapi.DockerBuildStrategyType,
1241 1240
 		DockerStrategy: &buildapi.DockerBuildStrategy{
1242 1241
 			NoCache: true,
1243 1242
 			From: &kapi.ObjectReference{
... ...
@@ -1250,7 +1238,6 @@ func mockDockerStrategyForDockerImage(name string) buildapi.BuildStrategy {
1250 1250
 
1251 1251
 func mockDockerStrategyForImageRepository() buildapi.BuildStrategy {
1252 1252
 	return buildapi.BuildStrategy{
1253
-		Type: buildapi.DockerBuildStrategyType,
1254 1253
 		DockerStrategy: &buildapi.DockerBuildStrategy{
1255 1254
 			NoCache: true,
1256 1255
 			From: &kapi.ObjectReference{
... ...
@@ -1264,7 +1251,6 @@ func mockDockerStrategyForImageRepository() buildapi.BuildStrategy {
1264 1264
 
1265 1265
 func mockCustomStrategyForDockerImage(name string) buildapi.BuildStrategy {
1266 1266
 	return buildapi.BuildStrategy{
1267
-		Type: buildapi.CustomBuildStrategyType,
1268 1267
 		CustomStrategy: &buildapi.CustomBuildStrategy{
1269 1268
 			From: kapi.ObjectReference{
1270 1269
 				Kind: "DockerImage",
... ...
@@ -1276,7 +1262,6 @@ func mockCustomStrategyForDockerImage(name string) buildapi.BuildStrategy {
1276 1276
 
1277 1277
 func mockCustomStrategyForImageRepository() buildapi.BuildStrategy {
1278 1278
 	return buildapi.BuildStrategy{
1279
-		Type: buildapi.CustomBuildStrategyType,
1280 1279
 		CustomStrategy: &buildapi.CustomBuildStrategy{
1281 1280
 			From: kapi.ObjectReference{
1282 1281
 				Kind:      "ImageStreamTag",
... ...
@@ -1304,7 +1289,6 @@ func mockBuild(source buildapi.BuildSource, strategy buildapi.BuildStrategy, out
1304 1304
 		Spec: buildapi.BuildSpec{
1305 1305
 			Source: source,
1306 1306
 			Revision: &buildapi.SourceRevision{
1307
-				Type: buildapi.BuildSourceGit,
1308 1307
 				Git: &buildapi.GitSourceRevision{
1309 1308
 					Commit: "1234",
1310 1309
 				},
... ...
@@ -1399,7 +1383,6 @@ func mockBuildGenerator() *BuildGenerator {
1399 1399
 func TestGenerateBuildFromConfigWithSecrets(t *testing.T) {
1400 1400
 	source := mocks.MockSource()
1401 1401
 	revision := &buildapi.SourceRevision{
1402
-		Type: buildapi.BuildSourceGit,
1403 1402
 		Git: &buildapi.GitSourceRevision{
1404 1403
 			Commit: "abcd",
1405 1404
 		},
... ...
@@ -72,7 +72,6 @@ func MockBuildConfig(source buildapi.BuildSource, strategy buildapi.BuildStrateg
72 72
 			BuildSpec: buildapi.BuildSpec{
73 73
 				Source: source,
74 74
 				Revision: &buildapi.SourceRevision{
75
-					Type: buildapi.BuildSourceGit,
76 75
 					Git: &buildapi.GitSourceRevision{
77 76
 						Commit: "1234",
78 77
 					},
... ...
@@ -86,7 +85,6 @@ func MockBuildConfig(source buildapi.BuildSource, strategy buildapi.BuildStrateg
86 86
 
87 87
 func MockSource() buildapi.BuildSource {
88 88
 	return buildapi.BuildSource{
89
-		Type: buildapi.BuildSourceGit,
90 89
 		Git: &buildapi.GitBuildSource{
91 90
 			URI: "http://test.repository/namespace/name",
92 91
 			Ref: "test-tag",
... ...
@@ -96,7 +94,6 @@ func MockSource() buildapi.BuildSource {
96 96
 
97 97
 func MockSourceStrategyForImageRepository() buildapi.BuildStrategy {
98 98
 	return buildapi.BuildStrategy{
99
-		Type: buildapi.SourceBuildStrategyType,
100 99
 		SourceStrategy: &buildapi.SourceBuildStrategy{
101 100
 			From: kapi.ObjectReference{
102 101
 				Kind:      "ImageStreamTag",
... ...
@@ -22,14 +22,12 @@ func TestBuildStrategy(t *testing.T) {
22 22
 		ObjectMeta: kapi.ObjectMeta{Name: "buildid", Namespace: "default"},
23 23
 		Spec: buildapi.BuildSpec{
24 24
 			Source: buildapi.BuildSource{
25
-				Type: buildapi.BuildSourceGit,
26 25
 				Git: &buildapi.GitBuildSource{
27 26
 					URI: "http://github.com/my/repository",
28 27
 				},
29 28
 				ContextDir: "context",
30 29
 			},
31 30
 			Strategy: buildapi.BuildStrategy{
32
-				Type:           buildapi.DockerBuildStrategyType,
33 31
 				DockerStrategy: &buildapi.DockerBuildStrategy{},
34 32
 			},
35 33
 			Output: buildapi.BuildOutput{
... ...
@@ -66,14 +64,12 @@ func TestBuildDecorator(t *testing.T) {
66 66
 		ObjectMeta: kapi.ObjectMeta{Name: "buildid", Namespace: "default"},
67 67
 		Spec: buildapi.BuildSpec{
68 68
 			Source: buildapi.BuildSource{
69
-				Type: buildapi.BuildSourceGit,
70 69
 				Git: &buildapi.GitBuildSource{
71 70
 					URI: "http://github.com/my/repository",
72 71
 				},
73 72
 				ContextDir: "context",
74 73
 			},
75 74
 			Strategy: buildapi.BuildStrategy{
76
-				Type:           buildapi.DockerBuildStrategyType,
77 75
 				DockerStrategy: &buildapi.DockerBuildStrategy{},
78 76
 			},
79 77
 			Output: buildapi.BuildOutput{
... ...
@@ -30,14 +30,12 @@ func TestBuildConfigStrategy(t *testing.T) {
30 30
 			},
31 31
 			BuildSpec: buildapi.BuildSpec{
32 32
 				Source: buildapi.BuildSource{
33
-					Type: buildapi.BuildSourceGit,
34 33
 					Git: &buildapi.GitBuildSource{
35 34
 						URI: "http://github.com/my/repository",
36 35
 					},
37 36
 					ContextDir: "context",
38 37
 				},
39 38
 				Strategy: buildapi.BuildStrategy{
40
-					Type:           buildapi.DockerBuildStrategyType,
41 39
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
42 40
 				},
43 41
 				Output: buildapi.BuildOutput{
... ...
@@ -126,7 +126,6 @@ func (h *binaryInstantiateHandler) handle(r io.Reader) (runtime.Object, error) {
126 126
 	request.Name = h.name
127 127
 	if len(h.options.Commit) > 0 {
128 128
 		request.Revision = &buildapi.SourceRevision{
129
-			Type: buildapi.BuildSourceGit,
130 129
 			Git: &buildapi.GitSourceRevision{
131 130
 				Committer: buildapi.SourceControlUser{
132 131
 					Name:  h.options.CommitterName,
... ...
@@ -31,21 +31,12 @@ func GetBuildName(pod *kapi.Pod) string {
31 31
 // GetImageStreamForStrategy returns the ImageStream[Tag/Image] ObjectReference associated
32 32
 // with the BuildStrategy.
33 33
 func GetImageStreamForStrategy(strategy buildapi.BuildStrategy) *kapi.ObjectReference {
34
-	switch strategy.Type {
35
-	case buildapi.SourceBuildStrategyType:
36
-		if strategy.SourceStrategy == nil {
37
-			return nil
38
-		}
34
+	switch {
35
+	case strategy.SourceStrategy != nil:
39 36
 		return &strategy.SourceStrategy.From
40
-	case buildapi.DockerBuildStrategyType:
41
-		if strategy.DockerStrategy == nil {
42
-			return nil
43
-		}
37
+	case strategy.DockerStrategy != nil:
44 38
 		return strategy.DockerStrategy.From
45
-	case buildapi.CustomBuildStrategyType:
46
-		if strategy.CustomStrategy == nil {
47
-			return nil
48
-		}
39
+	case strategy.CustomStrategy != nil:
49 40
 		return &strategy.CustomStrategy.From
50 41
 	default:
51 42
 		return nil
... ...
@@ -20,7 +20,6 @@ func (*okBuildConfigGetter) Get(namespace, name string) (*api.BuildConfig, error
20 20
 		Spec: api.BuildConfigSpec{
21 21
 			BuildSpec: api.BuildSpec{
22 22
 				Strategy: api.BuildStrategy{
23
-					Type: "Source",
24 23
 					SourceStrategy: &api.SourceBuildStrategy{
25 24
 						From: kapi.ObjectReference{
26 25
 							Kind: "DockerImage",
... ...
@@ -259,7 +258,6 @@ func TestInvokeWebhookOK(t *testing.T) {
259 259
 		Spec: api.BuildConfigSpec{
260 260
 			BuildSpec: api.BuildSpec{
261 261
 				Strategy: api.BuildStrategy{
262
-					Type: "Source",
263 262
 					SourceStrategy: &api.SourceBuildStrategy{
264 263
 						From: kapi.ObjectReference{
265 264
 							Kind: "DockerImage",
... ...
@@ -65,8 +65,7 @@ func (p *WebHookPlugin) Extract(buildCfg *api.BuildConfig, secret, path string,
65 65
 			for _, ref := range data.Git.Refs {
66 66
 				if webhook.GitRefMatches(ref.Ref, git.Ref) {
67 67
 					revision = &api.SourceRevision{
68
-						Type: api.BuildSourceGit,
69
-						Git:  &ref.GitSourceRevision,
68
+						Git: &ref.GitSourceRevision,
70 69
 					}
71 70
 					return revision, true, nil
72 71
 				}
... ...
@@ -79,8 +78,7 @@ func (p *WebHookPlugin) Extract(buildCfg *api.BuildConfig, secret, path string,
79 79
 			return nil, false, nil
80 80
 		}
81 81
 		revision = &api.SourceRevision{
82
-			Type: api.BuildSourceGit,
83
-			Git:  &data.Git.GitSourceRevision,
82
+			Git: &data.Git.GitSourceRevision,
84 83
 		}
85 84
 	}
86 85
 	return revision, true, nil
... ...
@@ -14,7 +14,6 @@ import (
14 14
 )
15 15
 
16 16
 var mockBuildStrategy = api.BuildStrategy{
17
-	Type: "STI",
18 17
 	SourceStrategy: &api.SourceBuildStrategy{
19 18
 		From: kapi.ObjectReference{
20 19
 			Name: "repository/image",
... ...
@@ -127,7 +126,6 @@ func TestExtractWithEmptyPayload(t *testing.T) {
127 127
 			},
128 128
 			BuildSpec: api.BuildSpec{
129 129
 				Source: api.BuildSource{
130
-					Type: api.BuildSourceGit,
131 130
 					Git: &api.GitBuildSource{
132 131
 						Ref: "master",
133 132
 					},
... ...
@@ -163,7 +161,6 @@ func TestExtractWithUnmatchedRefGitPayload(t *testing.T) {
163 163
 			},
164 164
 			BuildSpec: api.BuildSpec{
165 165
 				Source: api.BuildSource{
166
-					Type: api.BuildSourceGit,
167 166
 					Git: &api.GitBuildSource{
168 167
 						Ref: "asdfkasdfasdfasdfadsfkjhkhkh",
169 168
 					},
... ...
@@ -200,7 +197,6 @@ func TestExtractWithGitPayload(t *testing.T) {
200 200
 			},
201 201
 			BuildSpec: api.BuildSpec{
202 202
 				Source: api.BuildSource{
203
-					Type: api.BuildSourceGit,
204 203
 					Git: &api.GitBuildSource{
205 204
 						Ref: "master",
206 205
 					},
... ...
@@ -237,7 +233,6 @@ func TestExtractWithGitRefsPayload(t *testing.T) {
237 237
 			},
238 238
 			BuildSpec: api.BuildSpec{
239 239
 				Source: api.BuildSource{
240
-					Type: api.BuildSourceGit,
241 240
 					Git: &api.GitBuildSource{
242 241
 						Ref: "master",
243 242
 					},
... ...
@@ -274,7 +269,6 @@ func TestExtractWithUnmatchedGitRefsPayload(t *testing.T) {
274 274
 			},
275 275
 			BuildSpec: api.BuildSpec{
276 276
 				Source: api.BuildSource{
277
-					Type: api.BuildSourceGit,
278 277
 					Git: &api.GitBuildSource{
279 278
 						Ref: "other",
280 279
 					},
... ...
@@ -311,7 +305,7 @@ func TestGitlabPush(t *testing.T) {
311 311
 			},
312 312
 			BuildSpec: api.BuildSpec{
313 313
 				Source: api.BuildSource{
314
-					Type: api.BuildSourceGit,
314
+					Git: &api.GitBuildSource{},
315 315
 				},
316 316
 				Strategy: mockBuildStrategy,
317 317
 			},
... ...
@@ -343,7 +337,7 @@ func TestNonJsonPush(t *testing.T) {
343 343
 			},
344 344
 			BuildSpec: api.BuildSpec{
345 345
 				Source: api.BuildSource{
346
-					Type: api.BuildSourceGit,
346
+					Git: &api.GitBuildSource{},
347 347
 				},
348 348
 				Strategy: mockBuildStrategy,
349 349
 			},
... ...
@@ -382,7 +376,6 @@ func TestExtractWithUnmarshalError(t *testing.T) {
382 382
 			},
383 383
 			BuildSpec: api.BuildSpec{
384 384
 				Source: api.BuildSource{
385
-					Type: api.BuildSourceGit,
386 385
 					Git: &api.GitBuildSource{
387 386
 						Ref: "other",
388 387
 					},
... ...
@@ -72,7 +72,6 @@ func (p *WebHook) Extract(buildCfg *api.BuildConfig, secret, path string, req *h
72 72
 	}
73 73
 
74 74
 	revision = &api.SourceRevision{
75
-		Type: api.BuildSourceGit,
76 75
 		Git: &api.GitSourceRevision{
77 76
 			Commit:    event.HeadCommit.ID,
78 77
 			Author:    event.HeadCommit.Author,
... ...
@@ -29,7 +29,6 @@ func (c *okBuildConfigGetter) Get(namespace, name string) (*api.BuildConfig, err
29 29
 			},
30 30
 			BuildSpec: api.BuildSpec{
31 31
 				Source: api.BuildSource{
32
-					Type: api.BuildSourceGit,
33 32
 					Git: &api.GitBuildSource{
34 33
 						URI: "git://github.com/my/repo.git",
35 34
 					},
... ...
@@ -41,7 +40,6 @@ func (c *okBuildConfigGetter) Get(namespace, name string) (*api.BuildConfig, err
41 41
 }
42 42
 
43 43
 var mockBuildStrategy = api.BuildStrategy{
44
-	Type: "STI",
45 44
 	SourceStrategy: &api.SourceBuildStrategy{
46 45
 		From: kapi.ObjectReference{
47 46
 			Kind: "DockerImage",
... ...
@@ -221,7 +219,6 @@ func setup(t *testing.T, filename, eventType string) *testContext {
221 221
 				},
222 222
 				BuildSpec: api.BuildSpec{
223 223
 					Source: api.BuildSource{
224
-						Type: api.BuildSourceGit,
225 224
 						Git: &api.GitBuildSource{
226 225
 							URI: "git://github.com/my/repo.git",
227 226
 						},
... ...
@@ -189,7 +189,6 @@ func RunStartBuild(f *clientcmd.Factory, in io.Reader, out io.Writer, cmd *cobra
189 189
 	}
190 190
 	if len(commit) > 0 {
191 191
 		request.Revision = &buildapi.SourceRevision{
192
-			Type: buildapi.BuildSourceGit,
193 192
 			Git: &buildapi.GitSourceRevision{
194 193
 				Commit: commit,
195 194
 			},
... ...
@@ -552,8 +551,7 @@ func RunStartBuildWebHook(f *clientcmd.Factory, out io.Writer, webhook string, p
552 552
 func hookEventFromPostReceive(repo git.Repository, path, postReceivePath string) (*buildapi.GenericWebHookEvent, error) {
553 553
 	// TODO: support other types of refs
554 554
 	event := &buildapi.GenericWebHookEvent{
555
-		Type: buildapi.BuildSourceGit,
556
-		Git:  &buildapi.GitInfo{},
555
+		Git: &buildapi.GitInfo{},
557 556
 	}
558 557
 
559 558
 	// attempt to extract a post receive body
... ...
@@ -172,18 +172,8 @@ type BuildConfigDescriber struct {
172 172
 	host string
173 173
 }
174 174
 
175
-// TODO: remove when internal SourceBuildStrategyType is refactored to "Source"
176
-func describeStrategy(strategyType buildapi.BuildStrategyType) buildapi.BuildStrategyType {
177
-	if strategyType == buildapi.SourceBuildStrategyType {
178
-		strategyType = buildapi.BuildStrategyType("Source")
179
-	}
180
-	return strategyType
181
-}
182
-
183 175
 func describeBuildSpec(p buildapi.BuildSpec, out *tabwriter.Writer) {
184
-	formatString(out, "Strategy", describeStrategy(p.Strategy.Type))
185
-
186
-	formatString(out, "Source Type", p.Source.Type)
176
+	formatString(out, "Strategy", buildapi.StrategyType(p.Strategy))
187 177
 	if p.Source.Dockerfile != nil {
188 178
 		if len(strings.TrimSpace(*p.Source.Dockerfile)) == 0 {
189 179
 			formatString(out, "Dockerfile", "")
... ...
@@ -225,12 +215,12 @@ func describeBuildSpec(p buildapi.BuildSpec, out *tabwriter.Writer) {
225 225
 		}
226 226
 	}
227 227
 
228
-	switch p.Strategy.Type {
229
-	case buildapi.DockerBuildStrategyType:
228
+	switch {
229
+	case p.Strategy.DockerStrategy != nil:
230 230
 		describeDockerStrategy(p.Strategy.DockerStrategy, out)
231
-	case buildapi.SourceBuildStrategyType:
231
+	case p.Strategy.SourceStrategy != nil:
232 232
 		describeSourceStrategy(p.Strategy.SourceStrategy, out)
233
-	case buildapi.CustomBuildStrategyType:
233
+	case p.Strategy.CustomStrategy != nil:
234 234
 		describeCustomStrategy(p.Strategy.CustomStrategy, out)
235 235
 	}
236 236
 
... ...
@@ -246,7 +236,7 @@ func describeBuildSpec(p buildapi.BuildSpec, out *tabwriter.Writer) {
246 246
 		formatString(out, "Push Secret", p.Output.PushSecret.Name)
247 247
 	}
248 248
 
249
-	if p.Revision != nil && p.Revision.Type == buildapi.BuildSourceGit && p.Revision.Git != nil {
249
+	if p.Revision != nil && p.Revision.Git != nil {
250 250
 		buildDescriber := &BuildDescriber{}
251 251
 
252 252
 		formatString(out, "Git Commit", p.Revision.Git.Commit)
... ...
@@ -218,7 +218,7 @@ func printBuild(build *buildapi.Build, w io.Writer, withNamespace, wide, showAll
218 218
 	if len(build.Status.Reason) > 0 {
219 219
 		status = fmt.Sprintf("%s (%s)", status, build.Status.Reason)
220 220
 	}
221
-	_, err := fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\n", build.Name, describeStrategy(build.Spec.Strategy.Type), from, status, created, duration)
221
+	_, err := fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\n", build.Name, buildapi.StrategyType(build.Spec.Strategy), from, status, created, duration)
222 222
 	return err
223 223
 }
224 224
 
... ...
@@ -242,8 +242,8 @@ func describeSourceShort(spec buildapi.BuildSpec) string {
242 242
 		if rev := describeSourceGitRevision(spec); len(rev) != 0 {
243 243
 			from = fmt.Sprintf("%s@%s", from, rev)
244 244
 		}
245
-	case len(source.Type) > 0:
246
-		from = string(source.Type)
245
+	default:
246
+		from = buildapi.SourceType(source)
247 247
 	}
248 248
 	return from
249 249
 }
... ...
@@ -277,8 +277,8 @@ func printBuildList(buildList *buildapi.BuildList, w io.Writer, withNamespace, w
277 277
 }
278 278
 
279 279
 func printBuildConfig(bc *buildapi.BuildConfig, w io.Writer, withNamespace, wide, showAll bool, columnLabels []string) error {
280
-	if bc.Spec.Strategy.Type == buildapi.CustomBuildStrategyType {
281
-		_, err := fmt.Fprintf(w, "%s\t%v\t%s\t%d\n", bc.Name, describeStrategy(bc.Spec.Strategy.Type), bc.Spec.Strategy.CustomStrategy.From.Name, bc.Status.LastVersion)
280
+	if bc.Spec.Strategy.CustomStrategy != nil {
281
+		_, err := fmt.Fprintf(w, "%s\t%v\t%s\t%d\n", bc.Name, buildapi.StrategyType(bc.Spec.Strategy), bc.Spec.Strategy.CustomStrategy.From.Name, bc.Status.LastVersion)
282 282
 		return err
283 283
 	}
284 284
 
... ...
@@ -289,7 +289,7 @@ func printBuildConfig(bc *buildapi.BuildConfig, w io.Writer, withNamespace, wide
289 289
 			return err
290 290
 		}
291 291
 	}
292
-	_, err := fmt.Fprintf(w, "%s\t%v\t%s\t%d\n", bc.Name, describeStrategy(bc.Spec.Strategy.Type), from, bc.Status.LastVersion)
292
+	_, err := fmt.Fprintf(w, "%s\t%v\t%s\t%d\n", bc.Name, buildapi.StrategyType(bc.Spec.Strategy), from, bc.Status.LastVersion)
293 293
 	return err
294 294
 }
295 295
 
... ...
@@ -437,15 +437,15 @@ func describeImageTagInPipeline(image graphview.ImageTagLocation, namespace stri
437 437
 }
438 438
 
439 439
 func describeBuildInPipeline(build *buildapi.BuildConfig, baseImage graphview.ImageTagLocation) string {
440
-	switch build.Spec.Strategy.Type {
441
-	case buildapi.DockerBuildStrategyType:
440
+	switch {
441
+	case build.Spec.Strategy.DockerStrategy != nil:
442 442
 		// TODO: handle case where no source repo
443 443
 		source, ok := describeSourceInPipeline(&build.Spec.Source)
444 444
 		if !ok {
445 445
 			return fmt.Sprintf("bc/%s unconfigured docker build - no source set", build.Name)
446 446
 		}
447 447
 		return fmt.Sprintf("bc/%s docker build of %s", build.Name, source)
448
-	case buildapi.SourceBuildStrategyType:
448
+	case build.Spec.Strategy.SourceStrategy != nil:
449 449
 		source, ok := describeSourceInPipeline(&build.Spec.Source)
450 450
 		if !ok {
451 451
 			return fmt.Sprintf("bc/%s unconfigured source build", build.Name)
... ...
@@ -454,7 +454,7 @@ func describeBuildInPipeline(build *buildapi.BuildConfig, baseImage graphview.Im
454 454
 			return fmt.Sprintf("bc/%s %s; no image set", build.Name, source)
455 455
 		}
456 456
 		return fmt.Sprintf("bc/%s builds %s with %s", build.Name, source, baseImage.ImageSpec())
457
-	case buildapi.CustomBuildStrategyType:
457
+	case build.Spec.Strategy.CustomStrategy != nil:
458 458
 		source, ok := describeSourceInPipeline(&build.Spec.Source)
459 459
 		if !ok {
460 460
 			return fmt.Sprintf("bc/%s custom build ", build.Name)
... ...
@@ -602,14 +602,14 @@ func buildTimestamp(build *buildapi.Build) unversioned.Time {
602 602
 }
603 603
 
604 604
 func describeSourceInPipeline(source *buildapi.BuildSource) (string, bool) {
605
-	switch source.Type {
606
-	case buildapi.BuildSourceDockerfile:
607
-		return "Dockerfile", true
608
-	case buildapi.BuildSourceGit:
605
+	switch {
606
+	case source.Git != nil:
609 607
 		if len(source.Git.Ref) == 0 {
610 608
 			return source.Git.URI, true
611 609
 		}
612 610
 		return fmt.Sprintf("%s#%s", source.Git.URI, source.Git.Ref), true
611
+	case source.Dockerfile != nil:
612
+		return "Dockerfile", true
613 613
 	}
614 614
 	return "", false
615 615
 }
... ...
@@ -139,11 +139,9 @@ func (r *SourceRef) BuildSource() (*buildapi.BuildSource, []buildapi.BuildTrigge
139 139
 	source := &buildapi.BuildSource{}
140 140
 
141 141
 	if len(r.DockerfileContents) != 0 {
142
-		source.Type = buildapi.BuildSourceDockerfile
143 142
 		source.Dockerfile = &r.DockerfileContents
144 143
 	}
145 144
 	if r.URL != nil {
146
-		source.Type = buildapi.BuildSourceGit
147 145
 		source.Git = &buildapi.GitBuildSource{
148 146
 			URI: urlWithoutRef(*r.URL),
149 147
 			Ref: r.Ref,
... ...
@@ -151,7 +149,6 @@ func (r *SourceRef) BuildSource() (*buildapi.BuildSource, []buildapi.BuildTrigge
151 151
 		source.ContextDir = r.ContextDir
152 152
 	}
153 153
 	if r.Binary {
154
-		source.Type = buildapi.BuildSourceBinary
155 154
 		source.Binary = &buildapi.BinaryBuildSource{}
156 155
 	}
157 156
 	return source, triggers
... ...
@@ -176,13 +173,11 @@ func (s *BuildStrategyRef) BuildStrategy(env Environment) (*buildapi.BuildStrate
176 176
 			triggers = s.Base.BuildTriggers()
177 177
 		}
178 178
 		return &buildapi.BuildStrategy{
179
-			Type:           buildapi.DockerBuildStrategyType,
180 179
 			DockerStrategy: strategy,
181 180
 		}, triggers
182 181
 	}
183 182
 
184 183
 	return &buildapi.BuildStrategy{
185
-		Type: buildapi.SourceBuildStrategyType,
186 184
 		SourceStrategy: &buildapi.SourceBuildStrategy{
187 185
 			From: s.Base.ObjectReference(),
188 186
 			Env:  env.List(),
... ...
@@ -494,8 +494,6 @@ func addBuildsToGraph(g graph.Graph, builds *buildapi.BuildList) {
494 494
 // to the image specified by strategy.from, as long as the image is managed by
495 495
 // OpenShift.
496 496
 func addBuildStrategyImageReferencesToGraph(g graph.Graph, strategy buildapi.BuildStrategy, predecessor gonum.Node) {
497
-	glog.V(4).Infof("Examining build strategy with type %q", strategy.Type)
498
-
499 497
 	from := buildutil.GetImageStreamForStrategy(strategy)
500 498
 	if from == nil {
501 499
 		glog.V(4).Infof("Unable to determine 'from' reference - skipping")
... ...
@@ -257,7 +257,7 @@ func bcList(bcs ...buildapi.BuildConfig) buildapi.BuildConfigList {
257 257
 	}
258 258
 }
259 259
 
260
-func bc(namespace, name string, strategyType buildapi.BuildStrategyType, fromKind, fromNamespace, fromName string) buildapi.BuildConfig {
260
+func bc(namespace, name, strategyType, fromKind, fromNamespace, fromName string) buildapi.BuildConfig {
261 261
 	return buildapi.BuildConfig{
262 262
 		ObjectMeta: kapi.ObjectMeta{
263 263
 			Namespace: namespace,
... ...
@@ -275,7 +275,7 @@ func buildList(builds ...buildapi.Build) buildapi.BuildList {
275 275
 	}
276 276
 }
277 277
 
278
-func build(namespace, name string, strategyType buildapi.BuildStrategyType, fromKind, fromNamespace, fromName string) buildapi.Build {
278
+func build(namespace, name, strategyType, fromKind, fromNamespace, fromName string) buildapi.Build {
279 279
 	return buildapi.Build{
280 280
 		ObjectMeta: kapi.ObjectMeta{
281 281
 			Namespace: namespace,
... ...
@@ -285,14 +285,12 @@ func build(namespace, name string, strategyType buildapi.BuildStrategyType, from
285 285
 	}
286 286
 }
287 287
 
288
-func buildSpec(strategyType buildapi.BuildStrategyType, fromKind, fromNamespace, fromName string) buildapi.BuildSpec {
288
+func buildSpec(strategyType, fromKind, fromNamespace, fromName string) buildapi.BuildSpec {
289 289
 	spec := buildapi.BuildSpec{
290
-		Strategy: buildapi.BuildStrategy{
291
-			Type: strategyType,
292
-		},
290
+		Strategy: buildapi.BuildStrategy{},
293 291
 	}
294 292
 	switch strategyType {
295
-	case buildapi.SourceBuildStrategyType:
293
+	case "source":
296 294
 		spec.Strategy.SourceStrategy = &buildapi.SourceBuildStrategy{
297 295
 			From: kapi.ObjectReference{
298 296
 				Kind:      fromKind,
... ...
@@ -300,7 +298,7 @@ func buildSpec(strategyType buildapi.BuildStrategyType, fromKind, fromNamespace,
300 300
 				Name:      fromName,
301 301
 			},
302 302
 		}
303
-	case buildapi.DockerBuildStrategyType:
303
+	case "docker":
304 304
 		spec.Strategy.DockerStrategy = &buildapi.DockerBuildStrategy{
305 305
 			From: &kapi.ObjectReference{
306 306
 				Kind:      fromKind,
... ...
@@ -308,7 +306,7 @@ func buildSpec(strategyType buildapi.BuildStrategyType, fromKind, fromNamespace,
308 308
 				Name:      fromName,
309 309
 			},
310 310
 		}
311
-	case buildapi.CustomBuildStrategyType:
311
+	case "custom":
312 312
 		spec.Strategy.CustomStrategy = &buildapi.CustomBuildStrategy{
313 313
 			From: kapi.ObjectReference{
314 314
 				Kind:      fromKind,
... ...
@@ -494,62 +492,62 @@ func TestImagePruning(t *testing.T) {
494 494
 		},
495 495
 		"referenced by bc - sti - ImageStreamImage - don't prune": {
496 496
 			images:            imageList(image("id", registryURL+"/foo/bar@id")),
497
-			bcs:               bcList(bc("foo", "bc1", buildapi.SourceBuildStrategyType, "ImageStreamImage", "foo", "bar@id")),
497
+			bcs:               bcList(bc("foo", "bc1", "source", "ImageStreamImage", "foo", "bar@id")),
498 498
 			expectedDeletions: []string{},
499 499
 		},
500 500
 		"referenced by bc - docker - ImageStreamImage - don't prune": {
501 501
 			images:            imageList(image("id", registryURL+"/foo/bar@id")),
502
-			bcs:               bcList(bc("foo", "bc1", buildapi.DockerBuildStrategyType, "ImageStreamImage", "foo", "bar@id")),
502
+			bcs:               bcList(bc("foo", "bc1", "docker", "ImageStreamImage", "foo", "bar@id")),
503 503
 			expectedDeletions: []string{},
504 504
 		},
505 505
 		"referenced by bc - custom - ImageStreamImage - don't prune": {
506 506
 			images:            imageList(image("id", registryURL+"/foo/bar@id")),
507
-			bcs:               bcList(bc("foo", "bc1", buildapi.CustomBuildStrategyType, "ImageStreamImage", "foo", "bar@id")),
507
+			bcs:               bcList(bc("foo", "bc1", "custom", "ImageStreamImage", "foo", "bar@id")),
508 508
 			expectedDeletions: []string{},
509 509
 		},
510 510
 		"referenced by bc - sti - DockerImage - don't prune": {
511 511
 			images:            imageList(image("id", registryURL+"/foo/bar@id")),
512
-			bcs:               bcList(bc("foo", "bc1", buildapi.SourceBuildStrategyType, "DockerImage", "foo", registryURL+"/foo/bar@id")),
512
+			bcs:               bcList(bc("foo", "bc1", "source", "DockerImage", "foo", registryURL+"/foo/bar@id")),
513 513
 			expectedDeletions: []string{},
514 514
 		},
515 515
 		"referenced by bc - docker - DockerImage - don't prune": {
516 516
 			images:            imageList(image("id", registryURL+"/foo/bar@id")),
517
-			bcs:               bcList(bc("foo", "bc1", buildapi.DockerBuildStrategyType, "DockerImage", "foo", registryURL+"/foo/bar@id")),
517
+			bcs:               bcList(bc("foo", "bc1", "docker", "DockerImage", "foo", registryURL+"/foo/bar@id")),
518 518
 			expectedDeletions: []string{},
519 519
 		},
520 520
 		"referenced by bc - custom - DockerImage - don't prune": {
521 521
 			images:            imageList(image("id", registryURL+"/foo/bar@id")),
522
-			bcs:               bcList(bc("foo", "bc1", buildapi.CustomBuildStrategyType, "DockerImage", "foo", registryURL+"/foo/bar@id")),
522
+			bcs:               bcList(bc("foo", "bc1", "custom", "DockerImage", "foo", registryURL+"/foo/bar@id")),
523 523
 			expectedDeletions: []string{},
524 524
 		},
525 525
 		"referenced by build - sti - ImageStreamImage - don't prune": {
526 526
 			images:            imageList(image("id", registryURL+"/foo/bar@id")),
527
-			builds:            buildList(build("foo", "build1", buildapi.SourceBuildStrategyType, "ImageStreamImage", "foo", "bar@id")),
527
+			builds:            buildList(build("foo", "build1", "source", "ImageStreamImage", "foo", "bar@id")),
528 528
 			expectedDeletions: []string{},
529 529
 		},
530 530
 		"referenced by build - docker - ImageStreamImage - don't prune": {
531 531
 			images:            imageList(image("id", registryURL+"/foo/bar@id")),
532
-			builds:            buildList(build("foo", "build1", buildapi.DockerBuildStrategyType, "ImageStreamImage", "foo", "bar@id")),
532
+			builds:            buildList(build("foo", "build1", "docker", "ImageStreamImage", "foo", "bar@id")),
533 533
 			expectedDeletions: []string{},
534 534
 		},
535 535
 		"referenced by build - custom - ImageStreamImage - don't prune": {
536 536
 			images:            imageList(image("id", registryURL+"/foo/bar@id")),
537
-			builds:            buildList(build("foo", "build1", buildapi.CustomBuildStrategyType, "ImageStreamImage", "foo", "bar@id")),
537
+			builds:            buildList(build("foo", "build1", "custom", "ImageStreamImage", "foo", "bar@id")),
538 538
 			expectedDeletions: []string{},
539 539
 		},
540 540
 		"referenced by build - sti - DockerImage - don't prune": {
541 541
 			images:            imageList(image("id", registryURL+"/foo/bar@id")),
542
-			builds:            buildList(build("foo", "build1", buildapi.SourceBuildStrategyType, "DockerImage", "foo", registryURL+"/foo/bar@id")),
542
+			builds:            buildList(build("foo", "build1", "source", "DockerImage", "foo", registryURL+"/foo/bar@id")),
543 543
 			expectedDeletions: []string{},
544 544
 		},
545 545
 		"referenced by build - docker - DockerImage - don't prune": {
546 546
 			images:            imageList(image("id", registryURL+"/foo/bar@id")),
547
-			builds:            buildList(build("foo", "build1", buildapi.DockerBuildStrategyType, "DockerImage", "foo", registryURL+"/foo/bar@id")),
547
+			builds:            buildList(build("foo", "build1", "docker", "DockerImage", "foo", registryURL+"/foo/bar@id")),
548 548
 			expectedDeletions: []string{},
549 549
 		},
550 550
 		"referenced by build - custom - DockerImage - don't prune": {
551 551
 			images:            imageList(image("id", registryURL+"/foo/bar@id")),
552
-			builds:            buildList(build("foo", "build1", buildapi.CustomBuildStrategyType, "DockerImage", "foo", registryURL+"/foo/bar@id")),
552
+			builds:            buildList(build("foo", "build1", "custom", "DockerImage", "foo", registryURL+"/foo/bar@id")),
553 553
 			expectedDeletions: []string{},
554 554
 		},
555 555
 		"image stream - keep most recent n images": {
... ...
@@ -624,8 +622,8 @@ func TestImagePruning(t *testing.T) {
624 624
 			rcs:                    rcList(rc("foo", "rc1", registryURL+"/foo/bar@id2")),
625 625
 			pods:                   podList(pod("foo", "pod1", kapi.PodRunning, registryURL+"/foo/bar@id2")),
626 626
 			dcs:                    dcList(dc("foo", "rc1", registryURL+"/foo/bar@id")),
627
-			bcs:                    bcList(bc("foo", "bc1", buildapi.SourceBuildStrategyType, "DockerImage", "foo", registryURL+"/foo/bar@id")),
628
-			builds:                 buildList(build("foo", "build1", buildapi.CustomBuildStrategyType, "ImageStreamImage", "foo", "bar@id")),
627
+			bcs:                    bcList(bc("foo", "bc1", "source", "DockerImage", "foo", registryURL+"/foo/bar@id")),
628
+			builds:                 buildList(build("foo", "build1", "custom", "ImageStreamImage", "foo", "bar@id")),
629 629
 			expectedDeletions:      []string{},
630 630
 			expectedUpdatedStreams: []string{},
631 631
 		},
... ...
@@ -47,14 +47,12 @@ func TestAdmissionExists(t *testing.T) {
47 47
 		ObjectMeta: kapi.ObjectMeta{Name: "buildid"},
48 48
 		Spec: buildapi.BuildSpec{
49 49
 			Source: buildapi.BuildSource{
50
-				Type: buildapi.BuildSourceGit,
51 50
 				Git: &buildapi.GitBuildSource{
52 51
 					URI: "http://github.com/my/repository",
53 52
 				},
54 53
 				ContextDir: "context",
55 54
 			},
56 55
 			Strategy: buildapi.BuildStrategy{
57
-				Type:           buildapi.DockerBuildStrategyType,
58 56
 				DockerStrategy: &buildapi.DockerBuildStrategy{},
59 57
 			},
60 58
 			Output: buildapi.BuildOutput{
... ...
@@ -94,14 +92,12 @@ func TestAdmissionLifecycle(t *testing.T) {
94 94
 		ObjectMeta: kapi.ObjectMeta{Name: "buildid", Namespace: "other"},
95 95
 		Spec: buildapi.BuildSpec{
96 96
 			Source: buildapi.BuildSource{
97
-				Type: buildapi.BuildSourceGit,
98 97
 				Git: &buildapi.GitBuildSource{
99 98
 					URI: "http://github.com/my/repository",
100 99
 				},
101 100
 				ContextDir: "context",
102 101
 			},
103 102
 			Strategy: buildapi.BuildStrategy{
104
-				Type:           buildapi.DockerBuildStrategyType,
105 103
 				DockerStrategy: &buildapi.DockerBuildStrategy{},
106 104
 			},
107 105
 			Output: buildapi.BuildOutput{
... ...
@@ -110,8 +110,8 @@ func TestPolicyBasedRestrictionOfBuildConfigCreateAndInstantiateByStrategy(t *te
110 110
 	}
111 111
 }
112 112
 
113
-func buildStrategyTypes() []buildapi.BuildStrategyType {
114
-	return []buildapi.BuildStrategyType{buildapi.DockerBuildStrategyType, buildapi.SourceBuildStrategyType, buildapi.CustomBuildStrategyType}
113
+func buildStrategyTypes() []string {
114
+	return []string{"source", "docker", "custom"}
115 115
 }
116 116
 
117 117
 func setupBuildStrategyTest(t *testing.T) (clusterAdminClient, projectAdminClient, projectEditorClient *client.Client) {
... ...
@@ -202,37 +202,34 @@ func removeBuildStrategyPrivileges(t *testing.T, clusterRoleInterface client.Clu
202 202
 
203 203
 }
204 204
 
205
-func strategyForType(strategy buildapi.BuildStrategyType) buildapi.BuildStrategy {
205
+func strategyForType(strategy string) buildapi.BuildStrategy {
206 206
 	buildStrategy := buildapi.BuildStrategy{}
207
-	buildStrategy.Type = strategy
208 207
 	switch strategy {
209
-	case buildapi.DockerBuildStrategyType:
208
+	case "docker":
210 209
 		buildStrategy.DockerStrategy = &buildapi.DockerBuildStrategy{}
211
-	case buildapi.CustomBuildStrategyType:
210
+	case "custom":
212 211
 		buildStrategy.CustomStrategy = &buildapi.CustomBuildStrategy{}
213 212
 		buildStrategy.CustomStrategy.From.Name = "builderimage:latest"
214
-	case buildapi.SourceBuildStrategyType:
213
+	case "source":
215 214
 		buildStrategy.SourceStrategy = &buildapi.SourceBuildStrategy{}
216 215
 		buildStrategy.SourceStrategy.From.Name = "builderimage:latest"
217 216
 	}
218 217
 	return buildStrategy
219 218
 }
220 219
 
221
-func createBuild(t *testing.T, buildInterface client.BuildInterface, strategy buildapi.BuildStrategyType) (*buildapi.Build, error) {
220
+func createBuild(t *testing.T, buildInterface client.BuildInterface, strategy string) (*buildapi.Build, error) {
222 221
 	build := &buildapi.Build{}
223 222
 	build.GenerateName = strings.ToLower(string(strategy)) + "-build-"
224 223
 	build.Spec.Strategy = strategyForType(strategy)
225
-	build.Spec.Source.Type = buildapi.BuildSourceGit
226 224
 	build.Spec.Source.Git = &buildapi.GitBuildSource{URI: "example.org"}
227 225
 
228 226
 	return buildInterface.Create(build)
229 227
 }
230 228
 
231
-func createBuildConfig(t *testing.T, buildConfigInterface client.BuildConfigInterface, strategy buildapi.BuildStrategyType) (*buildapi.BuildConfig, error) {
229
+func createBuildConfig(t *testing.T, buildConfigInterface client.BuildConfigInterface, strategy string) (*buildapi.BuildConfig, error) {
232 230
 	buildConfig := &buildapi.BuildConfig{}
233 231
 	buildConfig.GenerateName = strings.ToLower(string(strategy)) + "-buildconfig-"
234 232
 	buildConfig.Spec.Strategy = strategyForType(strategy)
235
-	buildConfig.Spec.Source.Type = buildapi.BuildSourceGit
236 233
 	buildConfig.Spec.Source.Git = &buildapi.GitBuildSource{URI: "example.org"}
237 234
 
238 235
 	return buildConfigInterface.Create(buildConfig)
... ...
@@ -133,14 +133,12 @@ func mockBuildConfig() *buildapi.BuildConfig {
133 133
 			},
134 134
 			BuildSpec: buildapi.BuildSpec{
135 135
 				Source: buildapi.BuildSource{
136
-					Type: buildapi.BuildSourceGit,
137 136
 					Git: &buildapi.GitBuildSource{
138 137
 						URI: "http://my.docker/build",
139 138
 					},
140 139
 					ContextDir: "context",
141 140
 				},
142 141
 				Strategy: buildapi.BuildStrategy{
143
-					Type:           buildapi.DockerBuildStrategyType,
144 142
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
145 143
 				},
146 144
 				Output: buildapi.BuildOutput{
... ...
@@ -179,14 +177,12 @@ func TestBuildConfigClient(t *testing.T) {
179 179
 		Spec: buildapi.BuildConfigSpec{
180 180
 			BuildSpec: buildapi.BuildSpec{
181 181
 				Source: buildapi.BuildSource{
182
-					Type: buildapi.BuildSourceGit,
183 182
 					Git: &buildapi.GitBuildSource{
184 183
 						URI: "http://my.docker/build",
185 184
 					},
186 185
 					ContextDir: "context",
187 186
 				},
188 187
 				Strategy: buildapi.BuildStrategy{
189
-					Type:           buildapi.DockerBuildStrategyType,
190 188
 					DockerStrategy: &buildapi.DockerBuildStrategy{},
191 189
 				},
192 190
 				Output: buildapi.BuildOutput{
... ...
@@ -151,14 +151,12 @@ func mockBuild() *buildapi.Build {
151 151
 		},
152 152
 		Spec: buildapi.BuildSpec{
153 153
 			Source: buildapi.BuildSource{
154
-				Type: buildapi.BuildSourceGit,
155 154
 				Git: &buildapi.GitBuildSource{
156 155
 					URI: "http://my.docker/build",
157 156
 				},
158 157
 				ContextDir: "context",
159 158
 			},
160 159
 			Strategy: buildapi.BuildStrategy{
161
-				Type:           buildapi.DockerBuildStrategyType,
162 160
 				DockerStrategy: &buildapi.DockerBuildStrategy{},
163 161
 			},
164 162
 			Output: buildapi.BuildOutput{
... ...
@@ -382,24 +382,25 @@ func runImageChangeTriggerTest(t *testing.T, clusterAdminClient *client.Client,
382 382
 		t.Fatalf("expected watch event type %s, got %s", e, a)
383 383
 	}
384 384
 	newBuild := event.Object.(*buildapi.Build)
385
-	switch newBuild.Spec.Strategy.Type {
386
-	case buildapi.SourceBuildStrategyType:
387
-		if newBuild.Spec.Strategy.SourceStrategy.From.Name != "registry:8080/openshift/test-image-trigger:"+tag {
385
+	strategy := newBuild.Spec.Strategy
386
+	switch {
387
+	case strategy.SourceStrategy != nil:
388
+		if strategy.SourceStrategy.From.Name != "registry:8080/openshift/test-image-trigger:"+tag {
388 389
 			i, _ := clusterAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
389 390
 			bc, _ := clusterAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
390
-			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:"+tag, newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[0].ImageChange)
391
+			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:"+tag, strategy.SourceStrategy.From.Name, i, bc.Spec.Triggers[0].ImageChange)
391 392
 		}
392
-	case buildapi.DockerBuildStrategyType:
393
-		if newBuild.Spec.Strategy.DockerStrategy.From.Name != "registry:8080/openshift/test-image-trigger:"+tag {
393
+	case strategy.DockerStrategy != nil:
394
+		if strategy.DockerStrategy.From.Name != "registry:8080/openshift/test-image-trigger:"+tag {
394 395
 			i, _ := clusterAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
395 396
 			bc, _ := clusterAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
396
-			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:"+tag, newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[0].ImageChange)
397
+			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:"+tag, strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[0].ImageChange)
397 398
 		}
398
-	case buildapi.CustomBuildStrategyType:
399
-		if newBuild.Spec.Strategy.CustomStrategy.From.Name != "registry:8080/openshift/test-image-trigger:"+tag {
399
+	case strategy.CustomStrategy != nil:
400
+		if strategy.CustomStrategy.From.Name != "registry:8080/openshift/test-image-trigger:"+tag {
400 401
 			i, _ := clusterAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
401 402
 			bc, _ := clusterAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
402
-			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:"+tag, newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[0].ImageChange)
403
+			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:"+tag, strategy.CustomStrategy.From.Name, i, bc.Spec.Triggers[0].ImageChange)
403 404
 		}
404 405
 	}
405 406
 	// Wait for an update on the specific build that was added
... ...
@@ -475,24 +476,25 @@ WaitLoop2:
475 475
 		t.Fatalf("expected watch event type %s, got %s", e, a)
476 476
 	}
477 477
 	newBuild = event.Object.(*buildapi.Build)
478
-	switch newBuild.Spec.Strategy.Type {
479
-	case buildapi.SourceBuildStrategyType:
480
-		if newBuild.Spec.Strategy.SourceStrategy.From.Name != "registry:8080/openshift/test-image-trigger:ref-2-random" {
478
+	strategy = newBuild.Spec.Strategy
479
+	switch {
480
+	case strategy.SourceStrategy != nil:
481
+		if strategy.SourceStrategy.From.Name != "registry:8080/openshift/test-image-trigger:ref-2-random" {
481 482
 			i, _ := clusterAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
482 483
 			bc, _ := clusterAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
483
-			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2-random", newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[3].ImageChange)
484
+			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2-random", strategy.SourceStrategy.From.Name, i, bc.Spec.Triggers[3].ImageChange)
484 485
 		}
485
-	case buildapi.DockerBuildStrategyType:
486
-		if newBuild.Spec.Strategy.DockerStrategy.From.Name != "registry:8080/openshift/test-image-trigger:ref-2-random" {
486
+	case strategy.DockerStrategy != nil:
487
+		if strategy.DockerStrategy.From.Name != "registry:8080/openshift/test-image-trigger:ref-2-random" {
487 488
 			i, _ := clusterAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
488 489
 			bc, _ := clusterAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
489
-			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2-random", newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[3].ImageChange)
490
+			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2-random", strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[3].ImageChange)
490 491
 		}
491
-	case buildapi.CustomBuildStrategyType:
492
-		if newBuild.Spec.Strategy.CustomStrategy.From.Name != "registry:8080/openshift/test-image-trigger:ref-2-random" {
492
+	case strategy.CustomStrategy != nil:
493
+		if strategy.CustomStrategy.From.Name != "registry:8080/openshift/test-image-trigger:ref-2-random" {
493 494
 			i, _ := clusterAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
494 495
 			bc, _ := clusterAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
495
-			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2-random", newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[3].ImageChange)
496
+			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2-random", strategy.CustomStrategy.From.Name, i, bc.Spec.Triggers[3].ImageChange)
496 497
 		}
497 498
 	}
498 499
 
... ...
@@ -748,10 +750,8 @@ func configChangeBuildConfig() *buildapi.BuildConfig {
748 748
 	bc := &buildapi.BuildConfig{}
749 749
 	bc.Name = "testcfgbc"
750 750
 	bc.Namespace = testutil.Namespace()
751
-	bc.Spec.BuildSpec.Source.Type = buildapi.BuildSourceGit
752 751
 	bc.Spec.BuildSpec.Source.Git = &buildapi.GitBuildSource{}
753 752
 	bc.Spec.BuildSpec.Source.Git.URI = "git://github.com/openshift/ruby-hello-world.git"
754
-	bc.Spec.BuildSpec.Strategy.Type = buildapi.DockerBuildStrategyType
755 753
 	bc.Spec.BuildSpec.Strategy.DockerStrategy = &buildapi.DockerBuildStrategy{}
756 754
 	configChangeTrigger := buildapi.BuildTriggerPolicy{Type: buildapi.ConfigChangeBuildTriggerType}
757 755
 	bc.Spec.Triggers = append(bc.Spec.Triggers, configChangeTrigger)
... ...
@@ -82,7 +82,6 @@ func TestSimpleImageChangeBuildTriggerFromImageStreamTagCustomWithConfigChange(t
82 82
 
83 83
 func dockerStrategy(kind, name string) buildapi.BuildStrategy {
84 84
 	return buildapi.BuildStrategy{
85
-		Type: buildapi.DockerBuildStrategyType,
86 85
 		DockerStrategy: &buildapi.DockerBuildStrategy{
87 86
 			From: &kapi.ObjectReference{
88 87
 				Kind: kind,
... ...
@@ -93,7 +92,6 @@ func dockerStrategy(kind, name string) buildapi.BuildStrategy {
93 93
 }
94 94
 func stiStrategy(kind, name string) buildapi.BuildStrategy {
95 95
 	return buildapi.BuildStrategy{
96
-		Type: buildapi.SourceBuildStrategyType,
97 96
 		SourceStrategy: &buildapi.SourceBuildStrategy{
98 97
 			From: kapi.ObjectReference{
99 98
 				Kind: kind,
... ...
@@ -104,7 +102,6 @@ func stiStrategy(kind, name string) buildapi.BuildStrategy {
104 104
 }
105 105
 func customStrategy(kind, name string) buildapi.BuildStrategy {
106 106
 	return buildapi.BuildStrategy{
107
-		Type: buildapi.CustomBuildStrategyType,
108 107
 		CustomStrategy: &buildapi.CustomBuildStrategy{
109 108
 			From: kapi.ObjectReference{
110 109
 				Kind: kind,
... ...
@@ -124,7 +121,6 @@ func imageChangeBuildConfig(name string, strategy buildapi.BuildStrategy) *build
124 124
 		Spec: buildapi.BuildConfigSpec{
125 125
 			BuildSpec: buildapi.BuildSpec{
126 126
 				Source: buildapi.BuildSource{
127
-					Type: "Git",
128 127
 					Git: &buildapi.GitBuildSource{
129 128
 						URI: "git://github.com/openshift/ruby-hello-world.git",
130 129
 					},
... ...
@@ -243,26 +239,26 @@ func runTest(t *testing.T, testname string, projectAdminClient *client.Client, i
243 243
 		t.Fatalf("expected watch event type %s, got %s", e, a)
244 244
 	}
245 245
 	newBuild := event.Object.(*buildapi.Build)
246
-	switch newBuild.Spec.Strategy.Type {
247
-	case buildapi.SourceBuildStrategyType:
248
-		if newBuild.Spec.Strategy.SourceStrategy.From.Name != "registry:8080/openshift/test-image-trigger:"+tag {
246
+	strategy := newBuild.Spec.Strategy
247
+	switch {
248
+	case strategy.SourceStrategy != nil:
249
+		if strategy.SourceStrategy.From.Name != "registry:8080/openshift/test-image-trigger:"+tag {
249 250
 			i, _ := projectAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
250 251
 			bc, _ := projectAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
251
-			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:"+tag, newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[0].ImageChange)
252
+			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:"+tag, strategy.SourceStrategy.From.Name, i, bc.Spec.Triggers[0].ImageChange)
252 253
 		}
253
-	case buildapi.DockerBuildStrategyType:
254
-		if newBuild.Spec.Strategy.DockerStrategy.From.Name != "registry:8080/openshift/test-image-trigger:"+tag {
254
+	case strategy.DockerStrategy != nil:
255
+		if strategy.DockerStrategy.From.Name != "registry:8080/openshift/test-image-trigger:"+tag {
255 256
 			i, _ := projectAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
256 257
 			bc, _ := projectAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
257
-			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:"+tag, newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[0].ImageChange)
258
+			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:"+tag, strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[0].ImageChange)
258 259
 		}
259
-	case buildapi.CustomBuildStrategyType:
260
-		if newBuild.Spec.Strategy.CustomStrategy.From.Name != "registry:8080/openshift/test-image-trigger:"+tag {
260
+	case strategy.CustomStrategy != nil:
261
+		if strategy.CustomStrategy.From.Name != "registry:8080/openshift/test-image-trigger:"+tag {
261 262
 			i, _ := projectAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
262 263
 			bc, _ := projectAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
263
-			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:"+tag, newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[0].ImageChange)
264
+			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:"+tag, strategy.CustomStrategy.From.Name, i, bc.Spec.Triggers[0].ImageChange)
264 265
 		}
265
-
266 266
 	}
267 267
 	event = <-watch.ResultChan()
268 268
 	if e, a := watchapi.Modified, event.Type; e != a {
... ...
@@ -309,24 +305,25 @@ func runTest(t *testing.T, testname string, projectAdminClient *client.Client, i
309 309
 		t.Fatalf("expected watch event type %s, got %s", e, a)
310 310
 	}
311 311
 	newBuild = event.Object.(*buildapi.Build)
312
-	switch newBuild.Spec.Strategy.Type {
313
-	case buildapi.SourceBuildStrategyType:
314
-		if newBuild.Spec.Strategy.SourceStrategy.From.Name != "registry:8080/openshift/test-image-trigger:ref-2-random" {
312
+	strategy = newBuild.Spec.Strategy
313
+	switch {
314
+	case strategy.SourceStrategy != nil:
315
+		if strategy.SourceStrategy.From.Name != "registry:8080/openshift/test-image-trigger:ref-2-random" {
315 316
 			i, _ := projectAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
316 317
 			bc, _ := projectAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
317
-			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2-random", newBuild.Spec.Strategy.SourceStrategy.From.Name, i, bc.Spec.Triggers[3].ImageChange)
318
+			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2-random", strategy.SourceStrategy.From.Name, i, bc.Spec.Triggers[3].ImageChange)
318 319
 		}
319
-	case buildapi.DockerBuildStrategyType:
320
-		if newBuild.Spec.Strategy.DockerStrategy.From.Name != "registry:8080/openshift/test-image-trigger:ref-2-random" {
320
+	case strategy.DockerStrategy != nil:
321
+		if strategy.DockerStrategy.From.Name != "registry:8080/openshift/test-image-trigger:ref-2-random" {
321 322
 			i, _ := projectAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
322 323
 			bc, _ := projectAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
323
-			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2-random", newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[3].ImageChange)
324
+			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2-random", strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[3].ImageChange)
324 325
 		}
325
-	case buildapi.CustomBuildStrategyType:
326
-		if newBuild.Spec.Strategy.CustomStrategy.From.Name != "registry:8080/openshift/test-image-trigger:ref-2-random" {
326
+	case strategy.CustomStrategy != nil:
327
+		if strategy.CustomStrategy.From.Name != "registry:8080/openshift/test-image-trigger:ref-2-random" {
327 328
 			i, _ := projectAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
328 329
 			bc, _ := projectAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
329
-			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2-random", newBuild.Spec.Strategy.CustomStrategy.From.Name, i, bc.Spec.Triggers[3].ImageChange)
330
+			t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2-random", strategy.CustomStrategy.From.Name, i, bc.Spec.Triggers[3].ImageChange)
330 331
 		}
331 332
 	}
332 333
 
... ...
@@ -474,24 +471,25 @@ func TestMultipleImageChangeBuildTriggers(t *testing.T) {
474 474
 		newBuild := event.Object.(*buildapi.Build)
475 475
 		trigger := config.Spec.Triggers[tc.triggerIndex]
476 476
 		if trigger.ImageChange.From == nil {
477
-			switch newBuild.Spec.Strategy.Type {
478
-			case buildapi.SourceBuildStrategyType:
479
-				if newBuild.Spec.Strategy.SourceStrategy.From.Name != "registry:5000/openshift/"+tc.name+":"+tc.tag {
477
+			strategy := newBuild.Spec.Strategy
478
+			switch {
479
+			case strategy.SourceStrategy != nil:
480
+				if strategy.SourceStrategy.From.Name != "registry:5000/openshift/"+tc.name+":"+tc.tag {
480 481
 					i, _ := projectAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
481 482
 					bc, _ := projectAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
482
-					t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %#v", "registry:5000/openshift/"+tc.name+":"+tc.tag, newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[tc.triggerIndex].ImageChange)
483
+					t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %#v", "registry:5000/openshift/"+tc.name+":"+tc.tag, strategy.SourceStrategy.From.Name, i, bc.Spec.Triggers[tc.triggerIndex].ImageChange)
483 484
 				}
484
-			case buildapi.DockerBuildStrategyType:
485
-				if newBuild.Spec.Strategy.DockerStrategy.From.Name != "registry:8080/openshift/"+tc.name+":"+tc.tag {
485
+			case strategy.DockerStrategy != nil:
486
+				if strategy.DockerStrategy.From.Name != "registry:8080/openshift/"+tc.name+":"+tc.tag {
486 487
 					i, _ := projectAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
487 488
 					bc, _ := projectAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
488
-					t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %#v", "registry:5000/openshift/"+tc.name+":"+tag, newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[tc.triggerIndex].ImageChange)
489
+					t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %#v", "registry:5000/openshift/"+tc.name+":"+tag, strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[tc.triggerIndex].ImageChange)
489 490
 				}
490
-			case buildapi.CustomBuildStrategyType:
491
-				if newBuild.Spec.Strategy.CustomStrategy.From.Name != "registry:8080/openshift/"+tc.name+":"+tag {
491
+			case strategy.CustomStrategy != nil:
492
+				if strategy.CustomStrategy.From.Name != "registry:8080/openshift/"+tc.name+":"+tag {
492 493
 					i, _ := projectAdminClient.ImageStreams(testutil.Namespace()).Get(imageStream.Name)
493 494
 					bc, _ := projectAdminClient.BuildConfigs(testutil.Namespace()).Get(config.Name)
494
-					t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %#v", "registry:5000/openshift/"+tc.name+":"+tag, newBuild.Spec.Strategy.DockerStrategy.From.Name, i, bc.Spec.Triggers[tc.triggerIndex].ImageChange)
495
+					t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %#v", "registry:5000/openshift/"+tc.name+":"+tag, strategy.CustomStrategy.From.Name, i, bc.Spec.Triggers[tc.triggerIndex].ImageChange)
495 496
 				}
496 497
 
497 498
 			}
... ...
@@ -117,14 +117,12 @@ func TestProjectMustExist(t *testing.T) {
117 117
 		ObjectMeta: kapi.ObjectMeta{Name: "buildid", Namespace: "default"},
118 118
 		Spec: buildapi.BuildSpec{
119 119
 			Source: buildapi.BuildSource{
120
-				Type: buildapi.BuildSourceGit,
121 120
 				Git: &buildapi.GitBuildSource{
122 121
 					URI: "http://github.com/my/repository",
123 122
 				},
124 123
 				ContextDir: "context",
125 124
 			},
126 125
 			Strategy: buildapi.BuildStrategy{
127
-				Type:           buildapi.DockerBuildStrategyType,
128 126
 				DockerStrategy: &buildapi.DockerBuildStrategy{},
129 127
 			},
130 128
 			Output: buildapi.BuildOutput{
... ...
@@ -296,14 +296,12 @@ func mockBuildConfigImageParms(imageName, imageStream, imageTag string) *buildap
296 296
 			},
297 297
 			BuildSpec: buildapi.BuildSpec{
298 298
 				Source: buildapi.BuildSource{
299
-					Type: buildapi.BuildSourceGit,
300 299
 					Git: &buildapi.GitBuildSource{
301 300
 						URI: "http://my.docker/build",
302 301
 					},
303 302
 					ContextDir: "context",
304 303
 				},
305 304
 				Strategy: buildapi.BuildStrategy{
306
-					Type: buildapi.DockerBuildStrategyType,
307 305
 					DockerStrategy: &buildapi.DockerBuildStrategy{
308 306
 						From: &kapi.ObjectReference{
309 307
 							Kind: "DockerImage",
... ...
@@ -338,14 +336,12 @@ func mockBuildConfigImageStreamParms(imageName, imageStream, imageTag string) *b
338 338
 			},
339 339
 			BuildSpec: buildapi.BuildSpec{
340 340
 				Source: buildapi.BuildSource{
341
-					Type: buildapi.BuildSourceGit,
342 341
 					Git: &buildapi.GitBuildSource{
343 342
 						URI: "http://my.docker/build",
344 343
 					},
345 344
 					ContextDir: "context",
346 345
 				},
347 346
 				Strategy: buildapi.BuildStrategy{
348
-					Type: buildapi.SourceBuildStrategyType,
349 347
 					SourceStrategy: &buildapi.SourceBuildStrategy{
350 348
 						From: kapi.ObjectReference{
351 349
 							Kind: "ImageStreamTag",