Skip to content

Commit

Permalink
Merge pull request #193 from ysugimoto/add-override-host-test-config
Browse files Browse the repository at this point in the history 
implement testing.override_host function
  • Loading branch information
@ysugimoto
ysugimoto authored Oct 15, 2023
2 parents 762d1fe + 5290afd commit f9d166d
Show file tree
Hide file tree
Showing 17 changed files with 172 additions and 105 deletions.
12 changes: 6 additions & 6 deletions tester/function/assert.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,25 +6,25 @@ import (
"github.com/ysugimoto/falco/interpreter/value"
)

const Assert_lookup_Name = "assert"
const Assert_Name = "assert"

var Assert_lookup_ArgumentTypes = []value.Type{value.BooleanType}
var Assert_ArgumentTypes = []value.Type{value.BooleanType}

func Assert_lookup_Validate(args []value.Value) error {
func Assert_Validate(args []value.Value) error {
if len(args) < 1 || len(args) > 2 {
return errors.ArgumentNotInRange(Assert_lookup_Name, 1, 2, args)
return errors.ArgumentNotInRange(Assert_Name, 1, 2, args)
}

if len(args) == 2 {
if args[1].Type() != value.StringType {
return errors.TypeMismatch(Assert_lookup_Name, 2, value.StringType, args[1].Type())
return errors.TypeMismatch(Assert_Name, 2, value.StringType, args[1].Type())
}
}
return nil
}

func Assert(ctx *context.Context, args ...value.Value) (value.Value, error) {
if err := Assert_lookup_Validate(args); err != nil {
if err := Assert_Validate(args); err != nil {
return nil, errors.NewTestingError(err.Error())
}

Expand Down
18 changes: 9 additions & 9 deletions tester/function/assert_contains.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,31 +8,31 @@ import (
"github.com/ysugimoto/falco/interpreter/value"
)

const Assert_contains_lookup_Name = "assert"
const Assert_contains_Name = "assert"

var Assert_contains_lookup_ArgumentTypes = []value.Type{value.StringType, value.StringType}
var Assert_contains_ArgumentTypes = []value.Type{value.StringType, value.StringType}

func Assert_contains_lookup_Validate(args []value.Value) error {
func Assert_contains_Validate(args []value.Value) error {
if len(args) < 2 || len(args) > 3 {
return errors.ArgumentNotInRange(Assert_contains_lookup_Name, 2, 3, args)
return errors.ArgumentNotInRange(Assert_contains_Name, 2, 3, args)
}

for i := range Assert_contains_lookup_ArgumentTypes {
if args[i].Type() != Assert_contains_lookup_ArgumentTypes[i] {
return errors.TypeMismatch(Assert_contains_lookup_Name, i+1, Assert_contains_lookup_ArgumentTypes[i], args[i].Type())
for i := range Assert_contains_ArgumentTypes {
if args[i].Type() != Assert_contains_ArgumentTypes[i] {
return errors.TypeMismatch(Assert_contains_Name, i+1, Assert_contains_ArgumentTypes[i], args[i].Type())
}
}

if len(args) == 3 {
if args[2].Type() != value.StringType {
return errors.TypeMismatch(Assert_contains_lookup_Name, 3, value.StringType, args[2].Type())
return errors.TypeMismatch(Assert_contains_Name, 3, value.StringType, args[2].Type())
}
}
return nil
}

func Assert_contains(ctx *context.Context, args ...value.Value) (value.Value, error) {
if err := Assert_contains_lookup_Validate(args); err != nil {
if err := Assert_contains_Validate(args); err != nil {
return nil, errors.NewTestingError(err.Error())
}

Expand Down
18 changes: 9 additions & 9 deletions tester/function/assert_ends_with.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,31 +8,31 @@ import (
"github.com/ysugimoto/falco/interpreter/value"
)

const Assert_ends_with_lookup_Name = "assert"
const Assert_ends_with_Name = "assert"

var Assert_ends_with_lookup_ArgumentTypes = []value.Type{value.StringType, value.StringType}
var Assert_ends_with_ArgumentTypes = []value.Type{value.StringType, value.StringType}

func Assert_ends_with_lookup_Validate(args []value.Value) error {
func Assert_ends_with_Validate(args []value.Value) error {
if len(args) < 2 || len(args) > 3 {
return errors.ArgumentNotInRange(Assert_ends_with_lookup_Name, 2, 3, args)
return errors.ArgumentNotInRange(Assert_ends_with_Name, 2, 3, args)
}

for i := range Assert_ends_with_lookup_ArgumentTypes {
if args[i].Type() != Assert_ends_with_lookup_ArgumentTypes[i] {
return errors.TypeMismatch(Assert_ends_with_lookup_Name, i+1, Assert_ends_with_lookup_ArgumentTypes[i], args[i].Type())
for i := range Assert_ends_with_ArgumentTypes {
if args[i].Type() != Assert_ends_with_ArgumentTypes[i] {
return errors.TypeMismatch(Assert_ends_with_Name, i+1, Assert_ends_with_ArgumentTypes[i], args[i].Type())
}
}

if len(args) == 3 {
if args[2].Type() != value.StringType {
return errors.TypeMismatch(Assert_ends_with_lookup_Name, 3, value.StringType, args[2].Type())
return errors.TypeMismatch(Assert_ends_with_Name, 3, value.StringType, args[2].Type())
}
}
return nil
}

func Assert_ends_with(ctx *context.Context, args ...value.Value) (value.Value, error) {
if err := Assert_ends_with_lookup_Validate(args); err != nil {
if err := Assert_ends_with_Validate(args); err != nil {
return nil, errors.NewTestingError(err.Error())
}

Expand Down
10 changes: 5 additions & 5 deletions tester/function/assert_equal.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,22 +6,22 @@ import (
"github.com/ysugimoto/falco/interpreter/value"
)

const Assert_equal_lookup_Name = "assert"
const Assert_equal_Name = "assert"

func Assert_equal_lookup_Validate(args []value.Value) error {
func Assert_equal_Validate(args []value.Value) error {
if len(args) < 2 || len(args) > 3 {
return errors.ArgumentNotInRange(Assert_equal_lookup_Name, 2, 3, args)
return errors.ArgumentNotInRange(Assert_equal_Name, 2, 3, args)
}
if len(args) == 3 {
if args[2].Type() != value.StringType {
return errors.TypeMismatch(Assert_equal_lookup_Name, 3, value.StringType, args[2].Type())
return errors.TypeMismatch(Assert_equal_Name, 3, value.StringType, args[2].Type())
}
}
return nil
}

func Assert_equal(ctx *context.Context, args ...value.Value) (value.Value, error) {
if err := Assert_equal_lookup_Validate(args); err != nil {
if err := Assert_equal_Validate(args); err != nil {
return nil, errors.NewTestingError(err.Error())
}

Expand Down
10 changes: 5 additions & 5 deletions tester/function/assert_false.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,23 +6,23 @@ import (
"github.com/ysugimoto/falco/interpreter/value"
)

const Assert_false_lookup_Name = "assert"
const Assert_false_Name = "assert"

func Assert_false_lookup_Validate(args []value.Value) error {
func Assert_false_Validate(args []value.Value) error {
if len(args) < 1 || len(args) > 2 {
return errors.ArgumentNotInRange(Assert_false_lookup_Name, 1, 2, args)
return errors.ArgumentNotInRange(Assert_false_Name, 1, 2, args)
}

if len(args) == 2 {
if args[1].Type() != value.StringType {
return errors.TypeMismatch(Assert_false_lookup_Name, 2, value.StringType, args[1].Type())
return errors.TypeMismatch(Assert_false_Name, 2, value.StringType, args[1].Type())
}
}
return nil
}

func Assert_false(ctx *context.Context, args ...value.Value) (value.Value, error) {
if err := Assert_false_lookup_Validate(args); err != nil {
if err := Assert_false_Validate(args); err != nil {
return nil, errors.NewTestingError(err.Error())
}

Expand Down
18 changes: 9 additions & 9 deletions tester/function/assert_match.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,31 +8,31 @@ import (
"github.com/ysugimoto/falco/interpreter/value"
)

const Assert_match_lookup_Name = "assert"
const Assert_match_Name = "assert"

var Assert_match_lookup_ArgumentTypes = []value.Type{value.StringType, value.StringType}
var Assert_match_ArgumentTypes = []value.Type{value.StringType, value.StringType}

func Assert_match_lookup_Validate(args []value.Value) error {
func Assert_match_Validate(args []value.Value) error {
if len(args) < 2 || len(args) > 3 {
return errors.ArgumentNotInRange(Assert_match_lookup_Name, 2, 3, args)
return errors.ArgumentNotInRange(Assert_match_Name, 2, 3, args)
}

for i := range Assert_match_lookup_ArgumentTypes {
if args[i].Type() != Assert_match_lookup_ArgumentTypes[i] {
return errors.TypeMismatch(Assert_match_lookup_Name, i+1, Assert_match_lookup_ArgumentTypes[i], args[i].Type())
for i := range Assert_match_ArgumentTypes {
if args[i].Type() != Assert_match_ArgumentTypes[i] {
return errors.TypeMismatch(Assert_match_Name, i+1, Assert_match_ArgumentTypes[i], args[i].Type())
}
}

if len(args) == 3 {
if args[2].Type() != value.StringType {
return errors.TypeMismatch(Assert_match_lookup_Name, 3, value.StringType, args[2].Type())
return errors.TypeMismatch(Assert_match_Name, 3, value.StringType, args[2].Type())
}
}
return nil
}

func Assert_match(ctx *context.Context, args ...value.Value) (value.Value, error) {
if err := Assert_match_lookup_Validate(args); err != nil {
if err := Assert_match_Validate(args); err != nil {
return nil, errors.NewTestingError(err.Error())
}

Expand Down
18 changes: 9 additions & 9 deletions tester/function/assert_not_contains.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,31 +8,31 @@ import (
"github.com/ysugimoto/falco/interpreter/value"
)

const Assert_not_contains_lookup_Name = "assert"
const Assert_not_contains_Name = "assert"

var Assert_not_contains_lookup_ArgumentTypes = []value.Type{value.StringType, value.StringType}
var Assert_not_contains_ArgumentTypes = []value.Type{value.StringType, value.StringType}

func Assert_not_contains_lookup_Validate(args []value.Value) error {
func Assert_not_contains_Validate(args []value.Value) error {
if len(args) < 2 || len(args) > 3 {
return errors.ArgumentNotInRange(Assert_not_contains_lookup_Name, 2, 3, args)
return errors.ArgumentNotInRange(Assert_not_contains_Name, 2, 3, args)
}

for i := range Assert_not_contains_lookup_ArgumentTypes {
if args[i].Type() != Assert_not_contains_lookup_ArgumentTypes[i] {
return errors.TypeMismatch(Assert_not_contains_lookup_Name, i+1, Assert_not_contains_lookup_ArgumentTypes[i], args[i].Type())
for i := range Assert_not_contains_ArgumentTypes {
if args[i].Type() != Assert_not_contains_ArgumentTypes[i] {
return errors.TypeMismatch(Assert_not_contains_Name, i+1, Assert_not_contains_ArgumentTypes[i], args[i].Type())
}
}

if len(args) == 3 {
if args[2].Type() != value.StringType {
return errors.TypeMismatch(Assert_not_contains_lookup_Name, 3, value.StringType, args[2].Type())
return errors.TypeMismatch(Assert_not_contains_Name, 3, value.StringType, args[2].Type())
}
}
return nil
}

func Assert_not_contains(ctx *context.Context, args ...value.Value) (value.Value, error) {
if err := Assert_not_contains_lookup_Validate(args); err != nil {
if err := Assert_not_contains_Validate(args); err != nil {
return nil, errors.NewTestingError(err.Error())
}

Expand Down
10 changes: 5 additions & 5 deletions tester/function/assert_not_equal.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,22 +6,22 @@ import (
"github.com/ysugimoto/falco/interpreter/value"
)

const Assert_not_equal_lookup_Name = "assert"
const Assert_not_equal_Name = "assert"

func Assert_not_equal_lookup_Validate(args []value.Value) error {
func Assert_not_equal_Validate(args []value.Value) error {
if len(args) < 2 || len(args) > 3 {
return errors.ArgumentNotInRange(Assert_not_equal_lookup_Name, 2, 3, args)
return errors.ArgumentNotInRange(Assert_not_equal_Name, 2, 3, args)
}
if len(args) == 3 {
if args[2].Type() != value.StringType {
return errors.TypeMismatch(Assert_not_equal_lookup_Name, 3, value.StringType, args[2].Type())
return errors.TypeMismatch(Assert_not_equal_Name, 3, value.StringType, args[2].Type())
}
}
return nil
}

func Assert_not_equal(ctx *context.Context, args ...value.Value) (value.Value, error) {
if err := Assert_not_equal_lookup_Validate(args); err != nil {
if err := Assert_not_equal_Validate(args); err != nil {
return nil, errors.NewTestingError(err.Error())
}

Expand Down
18 changes: 9 additions & 9 deletions tester/function/assert_not_match.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,31 +8,31 @@ import (
"github.com/ysugimoto/falco/interpreter/value"
)

const Assert_not_match_lookup_Name = "assert"
const Assert_not_match_Name = "assert"

var Assert_not_match_lookup_ArgumentTypes = []value.Type{value.StringType, value.StringType}
var Assert_not_match_ArgumentTypes = []value.Type{value.StringType, value.StringType}

func Assert_not_match_lookup_Validate(args []value.Value) error {
func Assert_not_match_Validate(args []value.Value) error {
if len(args) < 2 || len(args) > 3 {
return errors.ArgumentNotInRange(Assert_not_match_lookup_Name, 2, 3, args)
return errors.ArgumentNotInRange(Assert_not_match_Name, 2, 3, args)
}

for i := range Assert_not_match_lookup_ArgumentTypes {
if args[i].Type() != Assert_not_match_lookup_ArgumentTypes[i] {
return errors.TypeMismatch(Assert_not_match_lookup_Name, i+1, Assert_not_match_lookup_ArgumentTypes[i], args[i].Type())
for i := range Assert_not_match_ArgumentTypes {
if args[i].Type() != Assert_not_match_ArgumentTypes[i] {
return errors.TypeMismatch(Assert_not_match_Name, i+1, Assert_not_match_ArgumentTypes[i], args[i].Type())
}
}

if len(args) == 3 {
if args[2].Type() != value.StringType {
return errors.TypeMismatch(Assert_not_match_lookup_Name, 3, value.StringType, args[2].Type())
return errors.TypeMismatch(Assert_not_match_Name, 3, value.StringType, args[2].Type())
}
}
return nil
}

func Assert_not_match(ctx *context.Context, args ...value.Value) (value.Value, error) {
if err := Assert_not_match_lookup_Validate(args); err != nil {
if err := Assert_not_match_Validate(args); err != nil {
return nil, errors.NewTestingError(err.Error())
}

Expand Down
10 changes: 5 additions & 5 deletions tester/function/assert_not_strict_equal.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,22 +6,22 @@ import (
"github.com/ysugimoto/falco/interpreter/value"
)

const Assert_not_strict_equal_lookup_Name = "assert"
const Assert_not_strict_equal_Name = "assert"

func Assert_not_strict_equal_lookup_Validate(args []value.Value) error {
func Assert_not_strict_equal_Validate(args []value.Value) error {
if len(args) < 2 || len(args) > 3 {
return errors.ArgumentNotInRange(Assert_not_strict_equal_lookup_Name, 2, 3, args)
return errors.ArgumentNotInRange(Assert_not_strict_equal_Name, 2, 3, args)
}
if len(args) == 3 {
if args[2].Type() != value.StringType {
return errors.TypeMismatch(Assert_not_strict_equal_lookup_Name, 3, value.StringType, args[2].Type())
return errors.TypeMismatch(Assert_not_strict_equal_Name, 3, value.StringType, args[2].Type())
}
}
return nil
}

func Assert_not_strict_equal(ctx *context.Context, args ...value.Value) (value.Value, error) {
if err := Assert_not_strict_equal_lookup_Validate(args); err != nil {
if err := Assert_not_strict_equal_Validate(args); err != nil {
return nil, errors.NewTestingError(err.Error())
}

Expand Down
18 changes: 9 additions & 9 deletions tester/function/assert_starts_with.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,31 +8,31 @@ import (
"github.com/ysugimoto/falco/interpreter/value"
)

const Assert_starts_with_lookup_Name = "assert"
const Assert_starts_with_Name = "assert"

var Assert_starts_with_lookup_ArgumentTypes = []value.Type{value.StringType, value.StringType}
var Assert_starts_with_ArgumentTypes = []value.Type{value.StringType, value.StringType}

func Assert_starts_with_lookup_Validate(args []value.Value) error {
func Assert_starts_with_Validate(args []value.Value) error {
if len(args) < 2 || len(args) > 3 {
return errors.ArgumentNotInRange(Assert_starts_with_lookup_Name, 2, 3, args)
return errors.ArgumentNotInRange(Assert_starts_with_Name, 2, 3, args)
}

for i := range Assert_starts_with_lookup_ArgumentTypes {
if args[i].Type() != Assert_starts_with_lookup_ArgumentTypes[i] {
return errors.TypeMismatch(Assert_starts_with_lookup_Name, i+1, Assert_starts_with_lookup_ArgumentTypes[i], args[i].Type())
for i := range Assert_starts_with_ArgumentTypes {
if args[i].Type() != Assert_starts_with_ArgumentTypes[i] {
return errors.TypeMismatch(Assert_starts_with_Name, i+1, Assert_starts_with_ArgumentTypes[i], args[i].Type())
}
}

if len(args) == 3 {
if args[2].Type() != value.StringType {
return errors.TypeMismatch(Assert_starts_with_lookup_Name, 3, value.StringType, args[2].Type())
return errors.TypeMismatch(Assert_starts_with_Name, 3, value.StringType, args[2].Type())
}
}
return nil
}

func Assert_starts_with(ctx *context.Context, args ...value.Value) (value.Value, error) {
if err := Assert_starts_with_lookup_Validate(args); err != nil {
if err := Assert_starts_with_Validate(args); err != nil {
return nil, errors.NewTestingError(err.Error())
}

Expand Down
Loading

0 comments on commit f9d166d

Please sign in to comment.