Add InList and NotInList

array.go

@@ -746,6 +746,115 @@ func (a *Array) Equal(value interface{}) *Array {
  return a.IsEqual(value)
 }
 
+// InList succeeds if whole array is equal to one of the elements from given
+// list of arrays.
+// Before comparison, both array and each value are converted to canonical
+// form.
+//
+// Each value should be a slice of any type.
+//
+// Example:
+//
+// array := NewArray(t, []interface{}{"foo", 123})
+// array.InList([]interface{}{"foo", 123}, []interface{}{"bar", "456"})
+func (a *Array) InList(values ...interface{}) *Array {
+ opChain := a.chain.enter("InList()")
+ defer opChain.leave()
+
+ if opChain.failed() {
+ return a
+ }
+
+ if len(values) == 0 {
+ opChain.fail(AssertionFailure{
+ Type: AssertUsage,
+ Errors: []error{
+ errors.New("unexpected empty list argument"),
+ },
+ })
+
+ return a
+ }
+
+ var isListed bool
+ for _, v := range values {
+ expected, ok := canonArray(opChain, v)
+ if !ok {
+ return a
+ }
+
+ if reflect.DeepEqual(expected, a.value) {
+ isListed = true
+ break
+ }
+ }
+
+ if !isListed {
+ opChain.fail(AssertionFailure{
+ Type: AssertBelongs,
+ Actual: &AssertionValue{a.value},
+ Expected: &AssertionValue{AssertionList(values)},
+ Errors: []error{
+ errors.New("expected: arrays is equal to one of the values"),
+ },
+ })
+ }
+
+ return a
+}
+
+// NotInList succeeds if whole array is not equal to any of the elements
+// from given list of arrays.
+// Before comparison, both array and each value are converted to canonical
+// form.
+//
+// Each value should be a slice of any type.
+//
+// Example:
+//
+// array := NewArray(t, []interface{}{"foo", 123})
+// array.NotInList([]interface{}{"bar", 456}, []interface{}{"baz", "foo"})
+func (a *Array) NotInList(values ...interface{}) *Array {
+ opChain := a.chain.enter("NotInList()")
+ defer opChain.leave()
+
+ if opChain.failed() {
+ return a
+ }
+
+ if len(values) == 0 {
+ opChain.fail(AssertionFailure{
+ Type: AssertUsage,
+ Errors: []error{
+ errors.New("unexpected empty list argument"),
+ },
+ })
+
+ return a
+ }
+
+ for _, v := range values {
+ expected, ok := canonArray(opChain, v)
+ if !ok {
+ return a
+ }
+
+ if reflect.DeepEqual(expected, a.value) {
+ opChain.fail(AssertionFailure{
+ Type: AssertNotBelongs,
+ Actual: &AssertionValue{a.value},
+ Expected: &AssertionValue{AssertionList(values)},
+ Errors: []error{
+ errors.New("expected: arrays is not equal to any of the values"),
+ },
+ })
+ break
+ }
+ }
+
+ return a
+}
+
 // IsEqualUnordered succeeds if array is equal to another array, ignoring element
 // order. Before comparison, both arrays are converted to canonical form.
 //

array_test.go

@@ -31,6 +31,8 @@ func TestArray_Failed(t *testing.T) {
  value.NotEmpty()
  value.IsEqual([]interface{}{})
  value.NotEqual([]interface{}{})
+ value.InList([]interface{}{})
+ value.NotInList([]interface{}{})
  value.IsEqualUnordered([]interface{}{})
  value.NotEqualUnordered([]interface{}{})
  value.ConsistsOf("foo")
@@ -377,6 +379,62 @@ func TestArray_EqualNotEmpty(t *testing.T) {
  value.chain.clearFailed()
 }
 
+func TestArray_InList(t *testing.T) {
+ reporter := newMockReporter(t)
+
+ value := NewArray(reporter, []interface{}{"foo", "bar"})
+
+ assert.Equal(t, []interface{}{"foo", "bar"}, value.Raw())
+
+ value.InList()
+ value.chain.assertFailed(t)
+ value.chain.clearFailed()
+
+ value.NotInList()
+ value.chain.assertFailed(t)
+ value.chain.clearFailed()
+
+ value.InList("foo", "bar")
+ value.chain.assertFailed(t)
+ value.chain.clearFailed()
+
+ value.NotInList("foo", "bar")
+ value.chain.assertFailed(t)
+ value.chain.clearFailed()
+
+ value.InList([]interface{}{})
+ value.chain.assertFailed(t)
+ value.chain.clearFailed()
+
+ value.NotInList([]interface{}{})
+ value.chain.assertNotFailed(t)
+ value.chain.clearFailed()
+
+ value.InList([]interface{}{"bar", "foo"})
+ value.chain.assertFailed(t)
+ value.chain.clearFailed()
+
+ value.NotInList([]interface{}{"bar", "foo"})
+ value.chain.assertNotFailed(t)
+ value.chain.clearFailed()
+
+ value.InList([]interface{}{"bar", "foo"}, []interface{}{"foo", "bar"})
+ value.chain.assertNotFailed(t)
+ value.chain.clearFailed()
+
+ value.NotInList([]interface{}{"bar", "foo"}, []interface{}{"foo", "bar"})
+ value.chain.assertFailed(t)
+ value.chain.clearFailed()
+
+ value.InList([]interface{}{"bar", "foo"}, []interface{}{"FOO", "BAR"})
+ value.chain.assertFailed(t)
+ value.chain.clearFailed()
+
+ value.NotInList([]interface{}{"bar", "foo"}, []interface{}{"FOO", "BAR"})
+ value.chain.assertNotFailed(t)
+ value.chain.clearFailed()
+}
+
 func TestArray_EqualTypes(t *testing.T) {
  reporter := newMockReporter(t)
 

assertion_test.go

@@ -336,18 +336,6 @@ func TestAssertion_ValidateTraits(t *testing.T) {
  List: fieldRequired,
  },
  },
- {
- testName: "AssertionList should not be slice of single element",
- errorContainsText: "AssertionList",
- failure: AssertionFailure{
- Expected: &AssertionValue{
- Value: AssertionList{[]int{1}},
- },
- },
- traits: fieldTraits{
- List: fieldRequired,
- },
- },
  }
 
  for _, test := range tests {
@@ -627,18 +615,6 @@ func TestAssertion_ValidateAssertion(t *testing.T) {
  Expected: &AssertionValue{AssertionList{}},
  },
  },
- {
- testName: "List has one element and it's list",
- errorContainsText: "AssertionList",
- input: AssertionFailure{
- Type: AssertBelongs,
- Errors: []error{
- errors.New("test"),
- },
- Actual: &AssertionValue{},
- Expected: &AssertionValue{AssertionList{[]string{"test"}}},
- },
- },
  }
 
  for _, test := range tests {

assertion_validation.go

@@ -3,7 +3,6 @@ package httpexpect
 import (
  "errors"
  "fmt"
- "reflect"
 )
 
 func validateAssertion(failure *AssertionFailure) error {
@@ -182,12 +181,6 @@ func validateTraits(failure *AssertionFailure, traits fieldTraits) error {
  if len(lst) == 0 {
  return errors.New("AssertionList should be non-empty")
  }
-
- if len(lst) == 1 && reflect.ValueOf(lst[0]).Kind() == reflect.Slice {
- return errors.New(
- "AssertionList should contain a list of values," +
- " but it contains a single element which itself is a list")
- }
  }
  }
  }

boolean.go

@@ -162,6 +162,97 @@ func (b *Boolean) Equal(value bool) *Boolean {
  return b.IsEqual(value)
 }
 
+// InList succeeds if boolean is equal to one of the elements from given
+// list of booleans.
+//
+// Example:
+//
+// boolean := NewBoolean(t, true)
+// boolean.InList(true, false)
+func (b *Boolean) InList(values ...bool) *Boolean {
+ opChain := b.chain.enter("InList()")
+ defer opChain.leave()
+
+ if opChain.failed() {
+ return b
+ }
+
+ if len(values) == 0 {
+ opChain.fail(AssertionFailure{
+ Type: AssertUsage,
+ Errors: []error{
+ errors.New("unexpected empty list argument"),
+ },
+ })
+
+ return b
+ }
+
+ var isListed bool
+ for _, v := range values {
+ if b.value == v {
+ isListed = true
+ break
+ }
+ }
+
+ if !isListed {
+ opChain.fail(AssertionFailure{
+ Type: AssertBelongs,
+ Actual: &AssertionValue{b.value},
+ Expected: &AssertionValue{AssertionList(boolList(values))},
+ Errors: []error{
+ errors.New("expected: boolean is equal to one of the values"),
+ },
+ })
+ }
+
+ return b
+}
+
+// NotInList succeeds if boolean is not equal to any of the elements from
+// given list of booleans.
+//
+// Example:
+//
+// boolean := NewBoolean(t, true)
+// boolean.NotInList(true, false)
+func (b *Boolean) NotInList(values ...bool) *Boolean {
+ opChain := b.chain.enter("NotInList()")
+ defer opChain.leave()
+
+ if opChain.failed() {
+ return b
+ }
+
+ if len(values) == 0 {
+ opChain.fail(AssertionFailure{
+ Type: AssertUsage,
+ Errors: []error{
+ errors.New("unexpected empty list argument"),
+ },
+ })
+
+ return b
+ }
+
+ for _, v := range values {
+ if b.value == v {
+ opChain.fail(AssertionFailure{
+ Type: AssertNotBelongs,
+ Actual: &AssertionValue{b.value},
+ Expected: &AssertionValue{AssertionList(boolList(values))},
+ Errors: []error{
+ errors.New("expected: boolean is not equal to any of the values"),
+ },
+ })
+ break
+ }
+ }
+
+ return b
+}
+
 // True succeeds if boolean is true.
 //
 // Example:
@@ -217,3 +308,12 @@ func (b *Boolean) False() *Boolean {
 
  return b
 }
+
+func boolList(values []bool) []interface{} {
+ l := make([]interface{}, 0, len(values))
+ for _, v := range values {
+ l = append(l, v)
+ }
+
+ return l
+}