You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by ts...@apache.org on 2022/11/30 03:54:57 UTC
[camel-k] 03/05: test(source): add tests for dataformat deps resolution
This is an automated email from the ASF dual-hosted git repository.
tsato pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-k.git
commit e9b8dd5d1369f6984b4241350afcb31257b26ead
Author: Tadayoshi Sato <sa...@gmail.com>
AuthorDate: Tue Nov 29 15:55:09 2022 +0900
test(source): add tests for dataformat deps resolution
---
pkg/util/source/inspector_groovy_test.go | 131 ++++++++---
pkg/util/source/inspector_java_script_test.go | 122 +++++++---
pkg/util/source/inspector_java_source_test.go | 128 ++++++++---
pkg/util/source/inspector_kotlin_test.go | 122 +++++++---
pkg/util/source/inspector_xml_test.go | 143 +++++++++---
pkg/util/source/inspector_yaml_test.go | 315 +++++++++++++-------------
pkg/util/source/test_support.go | 58 +++++
7 files changed, 700 insertions(+), 319 deletions(-)
diff --git a/pkg/util/source/inspector_groovy_test.go b/pkg/util/source/inspector_groovy_test.go
index d0d2a5e80..e082d9d74 100644
--- a/pkg/util/source/inspector_groovy_test.go
+++ b/pkg/util/source/inspector_groovy_test.go
@@ -21,34 +21,46 @@ import (
"fmt"
"testing"
- v1 "github.com/apache/camel-k/pkg/apis/camel/v1"
-
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/apache/camel-k/pkg/util/camel"
)
-const GroovyKameletEip = `
+func newTestGroovyInspector(t *testing.T) GroovyInspector {
+ t.Helper()
+
+ catalog, err := camel.DefaultCatalog()
+ require.NoError(t, err)
+
+ return GroovyInspector{
+ baseInspector: baseInspector{
+ catalog: catalog,
+ },
+ }
+}
+
+const groovyKameletEip = `
from("direct:start")
.kamelet("foo/bar?baz=test")
`
-const GroovyKameletEipSingleQuote = `
+const groovyKameletEipSingleQuote = `
from("direct:start")
.kamelet('foo/bar?baz=test')
`
-const GroovyKameletEndpoint = `
+const groovyKameletEndpoint = `
from("direct:start")
.to("kamelet:foo/bar?baz=test")
`
-const GroovyKameletEndpointSingleQuote = `
+const groovyKameletEndpointSingleQuote = `
from("direct:start")
.to('kamelet:foo/bar?baz=test')
`
-const GroovyWireTapEipSingleQuote = `
+const groovyWireTapEipSingleQuote = `
from("direct:start")
.wireTap('kamelet:foo/bar?baz=test')
`
@@ -59,53 +71,102 @@ func TestGroovyKamelet(t *testing.T) {
kamelets []string
}{
{
- source: GroovyKameletEip,
+ source: groovyKameletEip,
kamelets: []string{"foo/bar"},
},
{
- source: GroovyKameletEndpoint,
+ source: groovyKameletEndpoint,
kamelets: []string{"foo/bar"},
},
{
- source: GroovyKameletEipSingleQuote,
+ source: groovyKameletEipSingleQuote,
kamelets: []string{"foo/bar"},
},
{
- source: GroovyKameletEndpointSingleQuote,
+ source: groovyKameletEndpointSingleQuote,
kamelets: []string{"foo/bar"},
},
{
- source: GroovyWireTapEipSingleQuote,
+ source: groovyWireTapEipSingleQuote,
kamelets: []string{"foo/bar"},
},
}
+ inspector := newTestGroovyInspector(t)
for i := range tc {
test := tc[i]
t.Run(fmt.Sprintf("TestGroovyKamelet-%d", i), func(t *testing.T) {
- code := v1.SourceSpec{
- DataSpec: v1.DataSpec{
- Content: test.source,
- },
- }
-
- catalog, err := camel.DefaultCatalog()
- assert.Nil(t, err)
-
- meta := NewMetadata()
- inspector := GroovyInspector{
- baseInspector: baseInspector{
- catalog: catalog,
- },
- }
-
- err = inspector.Extract(code, &meta)
- assert.Nil(t, err)
- assert.True(t, meta.RequiredCapabilities.IsEmpty())
-
- for _, k := range test.kamelets {
- assert.Contains(t, meta.Kamelets, k)
- }
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ assert.True(t, meta.RequiredCapabilities.IsEmpty())
+ for _, k := range test.kamelets {
+ assert.Contains(t, meta.Kamelets, k)
+ }
+ })
+ })
+ }
+}
+
+const groovyJsonEip = `
+from("direct:start")
+ .unmarshal().json()
+`
+
+const groovyJsonJacksonEip = `
+from("direct:start")
+ .unmarshal().json(JsonLibrary.Jackson)
+`
+
+const groovyAvroEndpoint = `
+from("direct:start")
+ .to("dataformat:avro:marshal")
+`
+
+const groovyJacksonEndpoint = `
+from("direct:start")
+ .to("dataformat:jackson:marshal")
+`
+
+const groovyProtobufEndpoint = `
+from("direct:start")
+ .to("dataformat:protobuf:marshal")
+`
+
+func TestGroovyDataFormat(t *testing.T) {
+ tc := []struct {
+ source string
+ deps []string
+ }{
+ {
+ source: groovyJsonEip,
+ deps: []string{"camel:jackson"},
+ },
+ {
+ source: groovyJsonJacksonEip,
+ deps: []string{"camel:jackson"},
+ },
+ {
+ source: groovyAvroEndpoint,
+ deps: []string{"camel:dataformat", "camel:avro"},
+ },
+ {
+ source: groovyJacksonEndpoint,
+ deps: []string{"camel:dataformat", "camel:jackson"},
+ },
+ {
+ source: groovyProtobufEndpoint,
+ deps: []string{"camel:dataformat", "camel:protobuf"},
+ },
+ }
+
+ inspector := newTestGroovyInspector(t)
+ for i := range tc {
+ test := tc[i]
+ t.Run(fmt.Sprintf("TestGroovyDataFormat-%d", i), func(t *testing.T) {
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ for _, d := range test.deps {
+ assert.Contains(t, meta.Dependencies.List(), d)
+ }
+ })
})
}
}
diff --git a/pkg/util/source/inspector_java_script_test.go b/pkg/util/source/inspector_java_script_test.go
index 3ed09d928..59f53f476 100644
--- a/pkg/util/source/inspector_java_script_test.go
+++ b/pkg/util/source/inspector_java_script_test.go
@@ -21,23 +21,36 @@ import (
"fmt"
"testing"
- v1 "github.com/apache/camel-k/pkg/apis/camel/v1"
"github.com/apache/camel-k/pkg/util/camel"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
-const JavaScriptKameletEip = `
+func newTestJavaScriptInspector(t *testing.T) JavaScriptInspector {
+ t.Helper()
+
+ catalog, err := camel.DefaultCatalog()
+ require.NoError(t, err)
+
+ return JavaScriptInspector{
+ baseInspector: baseInspector{
+ catalog: catalog,
+ },
+ }
+}
+
+const javaScriptKameletEip = `
from("direct:start")
.kamelet("foo/bar?baz=test")
`
-const JavaScriptKameletEndpoint = `
+const javaScriptKameletEndpoint = `
from("direct:start")
.to("kamelet:foo/bar?baz=test")
`
-const JavaScriptWireTapEipSingleQuote = `
+const javaScriptWireTapEipSingleQuote = `
from("direct:start")
.wireTap('kamelet:foo/bar?baz=test')
`
@@ -48,45 +61,94 @@ func TestJavaScriptKamelet(t *testing.T) {
kamelets []string
}{
{
- source: JavaScriptKameletEip,
+ source: javaScriptKameletEip,
kamelets: []string{"foo/bar"},
},
{
- source: JavaScriptKameletEndpoint,
+ source: javaScriptKameletEndpoint,
kamelets: []string{"foo/bar"},
},
{
- source: JavaScriptWireTapEipSingleQuote,
+ source: javaScriptWireTapEipSingleQuote,
kamelets: []string{"foo/bar"},
},
}
+ inspector := newTestJavaScriptInspector(t)
for i := range tc {
test := tc[i]
t.Run(fmt.Sprintf("TestJavaScriptKamelet-%d", i), func(t *testing.T) {
- code := v1.SourceSpec{
- DataSpec: v1.DataSpec{
- Content: test.source,
- },
- }
-
- catalog, err := camel.DefaultCatalog()
- assert.Nil(t, err)
-
- meta := NewMetadata()
- inspector := JavaScriptInspector{
- baseInspector: baseInspector{
- catalog: catalog,
- },
- }
-
- err = inspector.Extract(code, &meta)
- assert.Nil(t, err)
- assert.True(t, meta.RequiredCapabilities.IsEmpty())
-
- for _, k := range test.kamelets {
- assert.Contains(t, meta.Kamelets, k)
- }
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ assert.True(t, meta.RequiredCapabilities.IsEmpty())
+ for _, k := range test.kamelets {
+ assert.Contains(t, meta.Kamelets, k)
+ }
+ })
+ })
+ }
+}
+
+const javaScriptJsonEip = `
+from('direct:start')
+ .unmarshal().json()
+`
+
+const javaScriptJsonJacksonEip = `
+from('direct:start')
+ .unmarshal().json(JsonLibrary.Jackson)
+`
+
+const javaScriptAvroEndpoint = `
+from('direct:start')
+ .to('dataformat:avro:marshal');
+`
+
+const javaScriptJacksonEndpoint = `
+from('direct:start')
+ .to('dataformat:jackson:marshal')
+`
+
+const javaScriptProtobufEndpoint = `
+from('direct:start')
+ .to('dataformat:protobuf:marshal')
+`
+
+func TestJavaScriptDataFormat(t *testing.T) {
+ tc := []struct {
+ source string
+ deps []string
+ }{
+ {
+ source: javaScriptJsonEip,
+ deps: []string{"camel:jackson"},
+ },
+ {
+ source: javaScriptJsonJacksonEip,
+ deps: []string{"camel:jackson"},
+ },
+ {
+ source: javaScriptAvroEndpoint,
+ deps: []string{"camel:dataformat", "camel:avro"},
+ },
+ {
+ source: javaScriptJacksonEndpoint,
+ deps: []string{"camel:dataformat", "camel:jackson"},
+ },
+ {
+ source: javaScriptProtobufEndpoint,
+ deps: []string{"camel:dataformat", "camel:protobuf"},
+ },
+ }
+
+ inspector := newTestJavaScriptInspector(t)
+ for i := range tc {
+ test := tc[i]
+ t.Run(fmt.Sprintf("TestJavaScriptDataFormat-%d", i), func(t *testing.T) {
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ for _, d := range test.deps {
+ assert.Contains(t, meta.Dependencies.List(), d)
+ }
+ })
})
}
}
diff --git a/pkg/util/source/inspector_java_source_test.go b/pkg/util/source/inspector_java_source_test.go
index af1a8e3af..6fddf4203 100644
--- a/pkg/util/source/inspector_java_source_test.go
+++ b/pkg/util/source/inspector_java_source_test.go
@@ -21,25 +21,38 @@ import (
"fmt"
"testing"
- v1 "github.com/apache/camel-k/pkg/apis/camel/v1"
"github.com/apache/camel-k/pkg/util/camel"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
-const JavaSourceKameletEip = `
+func newTestJavaSourceInspector(t *testing.T) JavaSourceInspector {
+ t.Helper()
+
+ catalog, err := camel.DefaultCatalog()
+ require.NoError(t, err)
+
+ return JavaSourceInspector{
+ baseInspector: baseInspector{
+ catalog: catalog,
+ },
+ }
+}
+
+const javaSourceKameletEip = `
from("direct:start")
- .kamelet("foo/bar?baz=test")
+ .kamelet("foo/bar?baz=test");
`
-const JavaSourceKameletEndpoint = `
+const javaSourceKameletEndpoint = `
from("direct:start")
- .to("kamelet:foo/bar?baz=test")
+ .to("kamelet:foo/bar?baz=test");
`
-const JavaSourceWireTapEip = `
+const javaSourceWireTapEip = `
from("direct:start")
- .wireTap("kamelet:foo/bar?baz=test")
+ .wireTap("kamelet:foo/bar?baz=test");
`
func TestJavaSourceKamelet(t *testing.T) {
@@ -48,45 +61,94 @@ func TestJavaSourceKamelet(t *testing.T) {
kamelets []string
}{
{
- source: JavaSourceKameletEip,
+ source: javaSourceKameletEip,
kamelets: []string{"foo/bar"},
},
{
- source: JavaSourceKameletEndpoint,
+ source: javaSourceKameletEndpoint,
kamelets: []string{"foo/bar"},
},
{
- source: JavaSourceWireTapEip,
+ source: javaSourceWireTapEip,
kamelets: []string{"foo/bar"},
},
}
+ inspector := newTestJavaSourceInspector(t)
for i := range tc {
test := tc[i]
t.Run(fmt.Sprintf("TestJavaSourceKamelet-%d", i), func(t *testing.T) {
- code := v1.SourceSpec{
- DataSpec: v1.DataSpec{
- Content: test.source,
- },
- }
-
- catalog, err := camel.DefaultCatalog()
- assert.Nil(t, err)
-
- meta := NewMetadata()
- inspector := JavaSourceInspector{
- baseInspector: baseInspector{
- catalog: catalog,
- },
- }
-
- err = inspector.Extract(code, &meta)
- assert.Nil(t, err)
- assert.True(t, meta.RequiredCapabilities.IsEmpty())
-
- for _, k := range test.kamelets {
- assert.Contains(t, meta.Kamelets, k)
- }
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ assert.True(t, meta.RequiredCapabilities.IsEmpty())
+ for _, k := range test.kamelets {
+ assert.Contains(t, meta.Kamelets, k)
+ }
+ })
+ })
+ }
+}
+
+const javaSourceJsonEip = `
+from("direct:start")
+ .unmarshal().json();
+`
+
+const javaSourceJsonJacksonEip = `
+from("direct:start")
+ .unmarshal().json(JsonLibrary.Jackson);
+`
+
+const javaSourceAvroEndpoint = `
+from("direct:start")
+ .to("dataformat:avro:marshal");
+`
+
+const javaSourceJacksonEndpoint = `
+from("direct:start")
+ .to("dataformat:jackson:marshal");
+`
+
+const javaSourceProtobufEndpoint = `
+from("direct:start")
+ .to("dataformat:protobuf:marshal");
+`
+
+func TestJavaSourceDataFormat(t *testing.T) {
+ tc := []struct {
+ source string
+ deps []string
+ }{
+ {
+ source: javaSourceJsonEip,
+ deps: []string{"camel:jackson"},
+ },
+ {
+ source: javaSourceJsonJacksonEip,
+ deps: []string{"camel:jackson"},
+ },
+ {
+ source: javaSourceAvroEndpoint,
+ deps: []string{"camel:dataformat", "camel:avro"},
+ },
+ {
+ source: javaSourceJacksonEndpoint,
+ deps: []string{"camel:dataformat", "camel:jackson"},
+ },
+ {
+ source: javaSourceProtobufEndpoint,
+ deps: []string{"camel:dataformat", "camel:protobuf"},
+ },
+ }
+
+ inspector := newTestJavaSourceInspector(t)
+ for i := range tc {
+ test := tc[i]
+ t.Run(fmt.Sprintf("TestJavaSourceDataFormat-%d", i), func(t *testing.T) {
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ for _, d := range test.deps {
+ assert.Contains(t, meta.Dependencies.List(), d)
+ }
+ })
})
}
}
diff --git a/pkg/util/source/inspector_kotlin_test.go b/pkg/util/source/inspector_kotlin_test.go
index 1b08fe2b3..436c0e4ad 100644
--- a/pkg/util/source/inspector_kotlin_test.go
+++ b/pkg/util/source/inspector_kotlin_test.go
@@ -21,23 +21,36 @@ import (
"fmt"
"testing"
- v1 "github.com/apache/camel-k/pkg/apis/camel/v1"
"github.com/apache/camel-k/pkg/util/camel"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
-const KotlinKameletEip = `
+func newTestKotlinInspector(t *testing.T) KotlinInspector {
+ t.Helper()
+
+ catalog, err := camel.DefaultCatalog()
+ require.NoError(t, err)
+
+ return KotlinInspector{
+ baseInspector: baseInspector{
+ catalog: catalog,
+ },
+ }
+}
+
+const kotlinKameletEip = `
from("direct:start")
.kamelet("foo/bar?baz=test")
`
-const KotlinKameletEndpoint = `
+const kotlinKameletEndpoint = `
from("direct:start")
.to("kamelet:foo/bar?baz=test")
`
-const KotlinWireTapEip = `
+const kotlinWireTapEip = `
from("direct:start")
.wireTap("kamelet:foo/bar?baz=test")
`
@@ -48,45 +61,94 @@ func TestKotlinKamelet(t *testing.T) {
kamelets []string
}{
{
- source: KotlinKameletEip,
+ source: kotlinKameletEip,
kamelets: []string{"foo/bar"},
},
{
- source: KotlinKameletEndpoint,
+ source: kotlinKameletEndpoint,
kamelets: []string{"foo/bar"},
},
{
- source: KotlinWireTapEip,
+ source: kotlinWireTapEip,
kamelets: []string{"foo/bar"},
},
}
+ inspector := newTestKotlinInspector(t)
for i := range tc {
test := tc[i]
t.Run(fmt.Sprintf("TestKotlinKamelet-%d", i), func(t *testing.T) {
- code := v1.SourceSpec{
- DataSpec: v1.DataSpec{
- Content: test.source,
- },
- }
-
- catalog, err := camel.DefaultCatalog()
- assert.Nil(t, err)
-
- meta := NewMetadata()
- inspector := KotlinInspector{
- baseInspector: baseInspector{
- catalog: catalog,
- },
- }
-
- err = inspector.Extract(code, &meta)
- assert.Nil(t, err)
- assert.True(t, meta.RequiredCapabilities.IsEmpty())
-
- for _, k := range test.kamelets {
- assert.Contains(t, meta.Kamelets, k)
- }
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ assert.True(t, meta.RequiredCapabilities.IsEmpty())
+ for _, k := range test.kamelets {
+ assert.Contains(t, meta.Kamelets, k)
+ }
+ })
+ })
+ }
+}
+
+const kotlinJsonEip = `
+from("direct:start")
+ .unmarshal().json()
+`
+
+const kotlinJsonJacksonEip = `
+from("direct:start")
+ .unmarshal().json(JsonLibrary.Jackson)
+`
+
+const kotlinAvroEndpoint = `
+from("direct:start")
+ .to("dataformat:avro:marshal")
+`
+
+const kotlinJacksonEndpoint = `
+from("direct:start")
+ .to("dataformat:jackson:marshal")
+`
+
+const kotlinProtobufEndpoint = `
+from("direct:start")
+ .to("dataformat:protobuf:marshal")
+`
+
+func TestKotlinDataFormat(t *testing.T) {
+ tc := []struct {
+ source string
+ deps []string
+ }{
+ {
+ source: kotlinJsonEip,
+ deps: []string{"camel:jackson"},
+ },
+ {
+ source: kotlinJsonJacksonEip,
+ deps: []string{"camel:jackson"},
+ },
+ {
+ source: kotlinAvroEndpoint,
+ deps: []string{"camel:dataformat", "camel:avro"},
+ },
+ {
+ source: kotlinJacksonEndpoint,
+ deps: []string{"camel:dataformat", "camel:jackson"},
+ },
+ {
+ source: kotlinProtobufEndpoint,
+ deps: []string{"camel:dataformat", "camel:protobuf"},
+ },
+ }
+
+ inspector := newTestKotlinInspector(t)
+ for i := range tc {
+ test := tc[i]
+ t.Run(fmt.Sprintf("TestKotlinDataFormat-%d", i), func(t *testing.T) {
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ for _, d := range test.deps {
+ assert.Contains(t, meta.Dependencies.List(), d)
+ }
+ })
})
}
}
diff --git a/pkg/util/source/inspector_xml_test.go b/pkg/util/source/inspector_xml_test.go
index 8552a84b7..86c090a32 100644
--- a/pkg/util/source/inspector_xml_test.go
+++ b/pkg/util/source/inspector_xml_test.go
@@ -21,13 +21,26 @@ import (
"fmt"
"testing"
- v1 "github.com/apache/camel-k/pkg/apis/camel/v1"
"github.com/apache/camel-k/pkg/util/camel"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
-const XMLKameletEip = `
+func newTestXMLInspector(t *testing.T) XMLInspector {
+ t.Helper()
+
+ catalog, err := camel.DefaultCatalog()
+ require.NoError(t, err)
+
+ return XMLInspector{
+ baseInspector: baseInspector{
+ catalog: catalog,
+ },
+ }
+}
+
+const xmlKameletEip = `
<camelContext xmlns="http://camel.apache.org/schema/spring">
<route>
<from uri="direct:start"/>
@@ -37,7 +50,7 @@ const XMLKameletEip = `
</camelContext>
`
-const XMLKameletEndpoint = `
+const xmlKameletEndpoint = `
<camelContext xmlns="http://camel.apache.org/schema/spring">
<route>
<from uri="direct:start"/>
@@ -46,7 +59,7 @@ const XMLKameletEndpoint = `
</camelContext>
`
-const XMLWireTapEndpoint = `
+const xmlWireTapEndpoint = `
<camelContext xmlns="http://camel.apache.org/schema/spring">
<route>
<from uri="direct:start"/>
@@ -61,45 +74,115 @@ func TestXMLKamelet(t *testing.T) {
kamelets []string
}{
{
- source: XMLKameletEip,
+ source: xmlKameletEip,
kamelets: []string{"foo/bar"},
},
{
- source: XMLKameletEndpoint,
+ source: xmlKameletEndpoint,
kamelets: []string{"foo/bar"},
},
{
- source: XMLWireTapEndpoint,
+ source: xmlWireTapEndpoint,
kamelets: []string{"foo/bar"},
},
}
+ inspector := newTestXMLInspector(t)
for i := range tc {
test := tc[i]
t.Run(fmt.Sprintf("TestXMLKamelet-%d", i), func(t *testing.T) {
- code := v1.SourceSpec{
- DataSpec: v1.DataSpec{
- Content: test.source,
- },
- }
-
- catalog, err := camel.DefaultCatalog()
- assert.Nil(t, err)
-
- meta := NewMetadata()
- inspector := XMLInspector{
- baseInspector: baseInspector{
- catalog: catalog,
- },
- }
-
- err = inspector.Extract(code, &meta)
- assert.Nil(t, err)
- assert.True(t, meta.RequiredCapabilities.IsEmpty())
-
- for _, k := range test.kamelets {
- assert.Contains(t, meta.Kamelets, k)
- }
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ assert.True(t, meta.RequiredCapabilities.IsEmpty())
+
+ for _, k := range test.kamelets {
+ assert.Contains(t, meta.Kamelets, k)
+ }
+ })
+ })
+ }
+}
+
+const xmlJsonEip = `
+<camelContext xmlns="http://camel.apache.org/schema/spring">
+ <route>
+ <from uri="direct:start"/>
+ <marshal><json/></marshal>
+ </route>
+</camelContext>
+`
+
+const xmlJsonJacksonEip = `
+<camelContext xmlns="http://camel.apache.org/schema/spring">
+ <route>
+ <from uri="direct:start"/>
+ <marshal><json library="Jackson"/></marshal>
+ </route>
+</camelContext>
+`
+
+const xmlAvroEndpoint = `
+<camelContext xmlns="http://camel.apache.org/schema/spring">
+ <route>
+ <from uri="direct:start"/>
+ <to uri="dataformat:avro:marshal"/>
+ </route>
+</camelContext>
+`
+
+const xmlJacksonEndpoint = `
+<camelContext xmlns="http://camel.apache.org/schema/spring">
+ <route>
+ <from uri="direct:start"/>
+ <to uri="dataformat:jackson:marshal"/>
+ </route>
+</camelContext>
+`
+
+const xmlProtobufEndpoint = `
+<camelContext xmlns="http://camel.apache.org/schema/spring">
+ <route>
+ <from uri="direct:start"/>
+ <to uri="dataformat:protobuf:marshal"/>
+ </route>
+</camelContext>
+`
+
+func TestXMLDataFormat(t *testing.T) {
+ tc := []struct {
+ source string
+ deps []string
+ }{
+ {
+ source: xmlJsonEip,
+ deps: []string{"camel:jackson"},
+ },
+ {
+ source: xmlJsonJacksonEip,
+ deps: []string{"camel:jackson"},
+ },
+ {
+ source: xmlAvroEndpoint,
+ deps: []string{"camel:dataformat", "camel:avro"},
+ },
+ {
+ source: xmlJacksonEndpoint,
+ deps: []string{"camel:dataformat", "camel:jackson"},
+ },
+ {
+ source: xmlProtobufEndpoint,
+ deps: []string{"camel:dataformat", "camel:protobuf"},
+ },
+ }
+
+ inspector := newTestXMLInspector(t)
+ for i := range tc {
+ test := tc[i]
+ t.Run(fmt.Sprintf("TestXMLDataFormat-%d", i), func(t *testing.T) {
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ for _, d := range test.deps {
+ assert.Contains(t, meta.Dependencies.List(), d)
+ }
+ })
})
}
}
diff --git a/pkg/util/source/inspector_yaml_test.go b/pkg/util/source/inspector_yaml_test.go
index 212993939..28e1d261e 100644
--- a/pkg/util/source/inspector_yaml_test.go
+++ b/pkg/util/source/inspector_yaml_test.go
@@ -22,16 +22,17 @@ import (
"testing"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
v1 "github.com/apache/camel-k/pkg/apis/camel/v1"
"github.com/apache/camel-k/pkg/util/camel"
)
-func NewtestYAMLInspector(t *testing.T) YAMLInspector {
+func newTestYAMLInspector(t *testing.T) YAMLInspector {
t.Helper()
catalog, err := camel.DefaultCatalog()
- assert.Nil(t, err)
+ require.NoError(t, err)
return YAMLInspector{
baseInspector: baseInspector{
@@ -40,7 +41,7 @@ func NewtestYAMLInspector(t *testing.T) YAMLInspector {
}
}
-const YAMLRouteConsumer = `
+const yamlRouteConsumer = `
- from:
uri: knative:endpoint/default
steps:
@@ -48,7 +49,7 @@ const YAMLRouteConsumer = `
uri: "log:out"
`
-const YAMLRouteProducer = `
+const yamlRouteProducer = `
- from:
uri: timer:tick
steps:
@@ -56,7 +57,7 @@ const YAMLRouteProducer = `
uri: knative:endpoint/service
`
-const YAMLRouteTransformer = `
+const yamlRouteTransformer = `
- from:
uri: knative:channel/mychannel
steps:
@@ -64,14 +65,14 @@ const YAMLRouteTransformer = `
uri: knative:endpoint/service
`
-const YAMLInvalid = `
+const yamlInvalid = `
- from:
uri: knative:endpoint/default
steps:
- "log:out"
`
-const YAMLInDepthChannel = `
+const yamlInDepthChannel = `
- from:
uri: knative:channel/mychannel
steps:
@@ -83,7 +84,7 @@ const YAMLInDepthChannel = `
uri: knative:endpoint/service
`
-const YAMLWireTapKnativeEIP = `
+const yamlWireTapKnativeEIP = `
- from:
uri: knative:channel/mychannel
parameters:
@@ -93,7 +94,7 @@ const YAMLWireTapKnativeEIP = `
uri: knative:channel/mychannel
`
-const YAMLWireTapJmsEIP = `
+const yamlWireTapJmsEIP = `
- from:
uri: knative:channel/mychannel
parameters:
@@ -112,78 +113,69 @@ func TestYAMLDependencies(t *testing.T) {
}{
{
name: "consumer",
- source: YAMLRouteConsumer,
+ source: yamlRouteConsumer,
dependencies: []string{`camel:knative`},
},
{
name: "producer",
- source: YAMLRouteProducer,
+ source: yamlRouteProducer,
dependencies: []string{`camel:knative`},
},
{
name: "transformer",
- source: YAMLRouteTransformer,
+ source: yamlRouteTransformer,
dependencies: []string{
`camel:knative`,
},
},
{
name: "invalid",
- source: YAMLInvalid,
+ source: yamlInvalid,
dependencies: []string{
`camel:knative`,
},
},
{
name: "in-depth",
- source: YAMLInDepthChannel,
+ source: yamlInDepthChannel,
dependencies: []string{
`camel:knative`,
},
},
{
name: "wire-tap-knative",
- source: YAMLWireTapKnativeEIP,
+ source: yamlWireTapKnativeEIP,
dependencies: []string{
`camel:knative`,
},
},
{
name: "wire-tap-jms",
- source: YAMLWireTapJmsEIP,
+ source: yamlWireTapJmsEIP,
dependencies: []string{
`camel:knative`,
`camel:jms`,
},
},
}
+
+ inspector := newTestYAMLInspector(t)
for i := range tests {
test := tests[i]
t.Run(test.name, func(t *testing.T) {
- code := v1.SourceSpec{
- DataSpec: v1.DataSpec{
- Name: "route.yaml",
- Content: test.source,
- },
- Language: v1.LanguageYaml,
- }
-
- meta := NewMetadata()
- inspector := NewtestYAMLInspector(t)
-
- err := inspector.Extract(code, &meta)
- assert.Nil(t, err)
- for _, dependency := range test.dependencies {
- assert.Contains(t, meta.Dependencies.List(), dependency)
- }
- for _, missingDependency := range test.missingDependencies {
- assert.NotContains(t, meta.Dependencies.List(), missingDependency)
- }
+ assertExtractYAML(t, inspector, test.source, func(meta *Metadata) {
+ for _, dependency := range test.dependencies {
+ assert.Contains(t, meta.Dependencies.List(), dependency)
+ }
+ for _, missingDependency := range test.missingDependencies {
+ assert.NotContains(t, meta.Dependencies.List(), missingDependency)
+ }
+ })
})
}
}
-const YAMLRestDSL = `
+const yamlRestDSL = `
- rest:
verb: "post"
uri: "/api/flow"
@@ -204,7 +196,7 @@ const YAMLRestDSL = `
uri: "log:out"
`
-const YAMLRestDSLWithRoute = `
+const yamlRestDSLWithRoute = `
- route:
id: "flow"
group: "routes"
@@ -229,30 +221,23 @@ const YAMLRestDSLWithRoute = `
`
func TestYAMLRestDSL(t *testing.T) {
- for name, content := range map[string]string{"YAMLRestDSL": YAMLRestDSL, "YAMLRestDSLWithRoute": YAMLRestDSLWithRoute} {
+ inspector := newTestYAMLInspector(t)
+ for name, content := range map[string]string{
+ "yamlRestDSL": yamlRestDSL,
+ "yamlRestDSLWithRoute": yamlRestDSLWithRoute,
+ } {
sourceContent := content
t.Run(name, func(t *testing.T) {
- code := v1.SourceSpec{
- DataSpec: v1.DataSpec{
- Name: "route.yaml",
- Content: sourceContent,
- },
- Language: v1.LanguageYaml,
- }
-
- meta := NewMetadata()
- inspector := NewtestYAMLInspector(t)
-
- err := inspector.Extract(code, &meta)
- assert.Nil(t, err)
- assert.True(t, meta.RequiredCapabilities.Has(v1.CapabilityRest))
- assert.True(t, meta.Dependencies.Has("camel:log"))
- assert.True(t, meta.ExposesHTTPServices)
+ assertExtractYAML(t, inspector, sourceContent, func(meta *Metadata) {
+ assert.True(t, meta.RequiredCapabilities.Has(v1.CapabilityRest))
+ assert.True(t, meta.Dependencies.Has("camel:log"))
+ assert.True(t, meta.ExposesHTTPServices)
+ })
})
}
}
-const YAMLFromDSL = `
+const yamlFromDSL = `
- from:
uri: "timer:tick"
parameters:
@@ -265,7 +250,7 @@ const YAMLFromDSL = `
- to: "log:info"
`
-const YAMLFromDSLWithRoute = `
+const yamlFromDSLWithRoute = `
- route:
id: route1
from:
@@ -281,30 +266,24 @@ const YAMLFromDSLWithRoute = `
`
func TestYAMLRouteAndFromEquivalence(t *testing.T) {
- for name, content := range map[string]string{"YAMLFromDSL": YAMLFromDSL, "YAMLFromDSLWithRoute": YAMLFromDSLWithRoute} {
+ inspector := newTestYAMLInspector(t)
+ for name, content := range map[string]string{
+ "yamlFromDSL": yamlFromDSL,
+ "yamlFromDSLWithRoute": yamlFromDSLWithRoute,
+ } {
sourceContent := content
t.Run(name, func(t *testing.T) {
- code := v1.SourceSpec{
- DataSpec: v1.DataSpec{
- Name: "route.yaml",
- Content: sourceContent,
- },
- Language: v1.LanguageYaml,
- }
-
- meta := NewMetadata()
- inspector := NewtestYAMLInspector(t)
- err := inspector.Extract(code, &meta)
- assert.Nil(t, err)
- assert.Equal(t, meta.FromURIs, []string{"timer:tick?period=5000"})
- assert.Equal(t, meta.ToURIs, []string{"log:info"})
- assert.True(t, meta.Dependencies.Has("camel:log"))
- assert.True(t, meta.Dependencies.Has("camel:timer"))
+ assertExtractYAML(t, inspector, sourceContent, func(meta *Metadata) {
+ assert.Equal(t, meta.FromURIs, []string{"timer:tick?period=5000"})
+ assert.Equal(t, meta.ToURIs, []string{"log:info"})
+ assert.True(t, meta.Dependencies.Has("camel:log"))
+ assert.True(t, meta.Dependencies.Has("camel:timer"))
+ })
})
}
}
-const YAMLJSONMarshal = `
+const yamlJSONMarshal = `
- from:
uri: timer:tick
steps:
@@ -312,7 +291,7 @@ const YAMLJSONMarshal = `
json: {}
`
-const YAMLJSONUnmarshal = `
+const yamlJSONUnmarshal = `
- from:
uri: timer:tick
steps:
@@ -320,7 +299,7 @@ const YAMLJSONUnmarshal = `
json: {}
`
-const YAMLJSONGsonMarshal = `
+const yamlJSONGsonMarshal = `
- from:
uri: timer:tick
steps:
@@ -329,7 +308,7 @@ const YAMLJSONGsonMarshal = `
library: Gson
`
-const YAMLJSONUnknownMarshal = `
+const yamlJSONUnknownMarshal = `
- from:
uri: timer:tick
steps:
@@ -344,60 +323,106 @@ func TestYAMLJson(t *testing.T) {
dependency string
}{
{
- source: YAMLJSONMarshal,
+ source: yamlJSONMarshal,
dependency: "camel:jackson",
},
{
- source: YAMLJSONUnmarshal,
+ source: yamlJSONUnmarshal,
dependency: "camel:jackson",
},
{
- source: YAMLJSONGsonMarshal,
+ source: yamlJSONGsonMarshal,
dependency: "camel:gson",
},
{
- source: YAMLJSONUnknownMarshal,
+ source: yamlJSONUnknownMarshal,
dependency: "camel:timer",
},
}
+ inspector := newTestYAMLInspector(t)
for i := range tc {
test := tc[i]
t.Run(fmt.Sprintf("%s-%d", test.dependency, i), func(t *testing.T) {
- code := v1.SourceSpec{
- DataSpec: v1.DataSpec{
- Name: "route.yaml",
- Content: test.source,
- },
- Language: v1.LanguageYaml,
- }
-
- meta := NewMetadata()
- inspector := NewtestYAMLInspector(t)
-
- err := inspector.Extract(code, &meta)
- assert.Nil(t, err)
- assert.True(t, meta.RequiredCapabilities.IsEmpty())
- assert.Contains(t, meta.Dependencies.List(), test.dependency)
+ assertExtractYAML(t, inspector, test.source, func(meta *Metadata) {
+ assert.True(t, meta.RequiredCapabilities.IsEmpty())
+ assert.Contains(t, meta.Dependencies.List(), test.dependency)
+ })
+ })
+ }
+}
+
+const yamlAvroEndpoint = `
+- from:
+ uri: direct:start
+ steps:
+ - to:
+ uri: dataformat:avro:marshal
+`
+
+const yamlJacksonEndpoint = `
+- from:
+ uri: direct:start
+ steps:
+ - to:
+ uri: dataformat:jackson:marshal
+`
+
+const yamlProtobufEndpoint = `
+- from:
+ uri: direct:start
+ steps:
+ - to:
+ uri: dataformat:protobuf:marshal
+`
+
+func TestYAMLDataFormat(t *testing.T) {
+ tc := []struct {
+ source string
+ deps []string
+ }{
+ {
+ source: yamlAvroEndpoint,
+ deps: []string{"camel:dataformat", "camel:avro"},
+ },
+ {
+ source: yamlJacksonEndpoint,
+ deps: []string{"camel:dataformat", "camel:jackson"},
+ },
+ {
+ source: yamlProtobufEndpoint,
+ deps: []string{"camel:dataformat", "camel:protobuf"},
+ },
+ }
+
+ inspector := newTestYAMLInspector(t)
+ for i := range tc {
+ test := tc[i]
+ t.Run(fmt.Sprintf("TestYAMLDataFormat-%d", i), func(t *testing.T) {
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ for _, d := range test.deps {
+ assert.Contains(t, meta.Dependencies.List(), d)
+ }
+ })
})
}
}
-const YAMLKameletEipNoID = `
+const yamlKameletEipNoID = `
- from:
uri: timer:tick
steps:
- kamelet: "foo"
`
-const YAMLKameletEipInline = `
+const yamlKameletEipInline = `
- from:
uri: timer:tick
steps:
- kamelet: "foo/bar?baz=test"
`
-const YAMLKameletEipMap = `
+const yamlKameletEipMap = `
- from:
uri: timer:tick
steps:
@@ -406,7 +431,7 @@ const YAMLKameletEipMap = `
`
// #nosec G101
-const YAMLKameletEipMapWithParams = `
+const yamlKameletEipMapWithParams = `
- from:
uri: timer:tick
steps:
@@ -416,7 +441,7 @@ const YAMLKameletEipMapWithParams = `
baz:test
`
-const YAMLKameletEndpoint = `
+const yamlKameletEndpoint = `
- from:
uri: timer:tick
steps:
@@ -429,58 +454,42 @@ func TestYAMLKamelet(t *testing.T) {
kamelets []string
}{
{
- source: YAMLKameletEipNoID,
+ source: yamlKameletEipNoID,
kamelets: []string{"foo"},
},
{
- source: YAMLKameletEipInline,
+ source: yamlKameletEipInline,
kamelets: []string{"foo/bar"},
},
{
- source: YAMLKameletEipMap,
+ source: yamlKameletEipMap,
kamelets: []string{"foo/bar"},
},
{
- source: YAMLKameletEipMapWithParams,
+ source: yamlKameletEipMapWithParams,
kamelets: []string{"foo/bar"},
},
{
- source: YAMLKameletEndpoint,
+ source: yamlKameletEndpoint,
kamelets: []string{"foo/bar"},
},
}
+ inspector := newTestYAMLInspector(t)
for i := range tc {
test := tc[i]
t.Run(fmt.Sprintf("TestYAMLKamelet-%d", i), func(t *testing.T) {
- code := v1.SourceSpec{
- DataSpec: v1.DataSpec{
- Content: test.source,
- },
- }
-
- catalog, err := camel.DefaultCatalog()
- assert.Nil(t, err)
-
- meta := NewMetadata()
- inspector := YAMLInspector{
- baseInspector: baseInspector{
- catalog: catalog,
- },
- }
-
- err = inspector.Extract(code, &meta)
- assert.Nil(t, err)
- assert.True(t, meta.RequiredCapabilities.IsEmpty())
-
- for _, k := range test.kamelets {
- assert.Contains(t, meta.Kamelets, k)
- }
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ assert.True(t, meta.RequiredCapabilities.IsEmpty())
+ for _, k := range test.kamelets {
+ assert.Contains(t, meta.Kamelets, k)
+ }
+ })
})
}
}
-const YAMLKameletExplicitParams = `
+const yamlKameletExplicitParams = `
- from:
uri: cron:tab
parameters:
@@ -492,7 +501,7 @@ const YAMLKameletExplicitParams = `
cloudEventsSpecVersion: "1.0"
`
-const YAMLKameletExplicitNumericParams = `
+const yamlKameletExplicitNumericParams = `
- from:
uri: timer:tick
parameters:
@@ -508,47 +517,31 @@ func TestYAMLExplicitParameters(t *testing.T) {
toURIs []string
}{
{
- source: YAMLKameletExplicitParams,
+ source: yamlKameletExplicitParams,
fromURIs: []string{"cron:tab?schedule=%2A+%2A+%2A+%2A+%3F"},
toURIs: []string{"knative:channel/a?cloudEventsSpecVersion=1.0"},
},
{
- source: YAMLKameletExplicitNumericParams,
+ source: yamlKameletExplicitNumericParams,
fromURIs: []string{"timer:tick?period=1000"},
},
}
+ inspector := newTestYAMLInspector(t)
for i := range tc {
test := tc[i]
t.Run(fmt.Sprintf("TestYAMLExplicitParameters-%d", i), func(t *testing.T) {
- code := v1.SourceSpec{
- DataSpec: v1.DataSpec{
- Content: test.source,
- },
- }
-
- catalog, err := camel.DefaultCatalog()
- assert.Nil(t, err)
-
- meta := NewMetadata()
- inspector := YAMLInspector{
- baseInspector: baseInspector{
- catalog: catalog,
- },
- }
-
- err = inspector.Extract(code, &meta)
- assert.Nil(t, err)
- assert.True(t, meta.RequiredCapabilities.IsEmpty())
-
- assert.Len(t, meta.FromURIs, len(test.fromURIs))
- for _, k := range test.fromURIs {
- assert.Contains(t, meta.FromURIs, k)
- }
- assert.Len(t, meta.ToURIs, len(test.toURIs))
- for _, k := range test.toURIs {
- assert.Contains(t, meta.ToURIs, k)
- }
+ assertExtract(t, inspector, test.source, func(meta *Metadata) {
+ assert.True(t, meta.RequiredCapabilities.IsEmpty())
+ assert.Len(t, meta.FromURIs, len(test.fromURIs))
+ for _, k := range test.fromURIs {
+ assert.Contains(t, meta.FromURIs, k)
+ }
+ assert.Len(t, meta.ToURIs, len(test.toURIs))
+ for _, k := range test.toURIs {
+ assert.Contains(t, meta.ToURIs, k)
+ }
+ })
})
}
}
diff --git a/pkg/util/source/test_support.go b/pkg/util/source/test_support.go
new file mode 100644
index 000000000..7d1863a77
--- /dev/null
+++ b/pkg/util/source/test_support.go
@@ -0,0 +1,58 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements. See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package source
+
+import (
+ "testing"
+
+ v1 "github.com/apache/camel-k/pkg/apis/camel/v1"
+
+ "github.com/stretchr/testify/require"
+)
+
+func assertExtract(t *testing.T, inspector Inspector, source string, assertFn func(meta *Metadata)) {
+ t.Helper()
+
+ srcSpec := v1.SourceSpec{
+ DataSpec: v1.DataSpec{
+ Content: source,
+ },
+ }
+ meta := NewMetadata()
+ err := inspector.Extract(srcSpec, &meta)
+ require.NoError(t, err)
+
+ assertFn(&meta)
+}
+
+func assertExtractYAML(t *testing.T, inspector YAMLInspector, source string, assertFn func(meta *Metadata)) {
+ t.Helper()
+
+ srcSpec := v1.SourceSpec{
+ DataSpec: v1.DataSpec{
+ Name: "route.yaml",
+ Content: source,
+ },
+ Language: v1.LanguageYaml,
+ }
+ meta := NewMetadata()
+ err := inspector.Extract(srcSpec, &meta)
+ require.NoError(t, err)
+
+ assertFn(&meta)
+}