Example #1
0
func TestStable(t *testing.T) {
	input := []optimus.Row{
		{"c": "a", "b": "a"},
		{"c": "a", "b": "b"},
		{"c": "a", "b": "c"},
		{"c": "a", "b": "d"},
		{"c": "a", "b": "e"},
		{"c": "a", "b": "f"},
		{"c": "a", "b": "g"},
		{"c": "a", "b": "h"},
		{"c": "a", "b": "i"},
		{"c": "a", "b": "j"},
		{"c": "a", "b": "k"},
		{"c": "a", "b": "l"},
		{"c": "a", "b": "m"},
		{"c": "a", "b": "n"},
		{"c": "a", "b": "o"},
		{"c": "a", "b": "p"},
		{"c": "a", "b": "q"},
		{"c": "a", "b": "r"},
		{"c": "a", "b": "s"},
		{"c": "a", "b": "t"},
		{"c": "a", "b": "u"},
		{"c": "a", "b": "v"},
		{"c": "a", "b": "w"},
		{"c": "a", "b": "x"},
		{"c": "a", "b": "y"},
		{"c": "a", "b": "z"},
	}

	table := optimus.Transform(slice.New(input), StableSort(byStringKey("c")))
	actual := tests.GetRows(table)
	assert.Nil(t, table.Err())
	assert.Equal(t, actual, input)
}
Example #2
0
func TestPairSuccess(t *testing.T) {
	filterRows := func(rows []optimus.Row, filterFn func(optimus.Row) (bool, error)) []optimus.Row {
		out := []optimus.Row{}
		for _, row := range rows {
			if f, _ := filterFn(row); f {
				out = append(out, row)
			}
		}
		return out
	}
	for _, joinTest := range joinTests {
		for _, joinFilter := range joinFilters {
			left := slice.New(joinTest.left)
			right := slice.New(joinTest.right)

			pair := Pair(right, joinTest.leftID, joinTest.rightID, joinFilter)
			table := optimus.Transform(left, pair)

			actual := tests.GetRows(table)

			assert.Equal(t, filterRows(joinTest.expected, joinFilter), actual)
			assert.Nil(t, table.Err())
		}
	}
}
Example #3
0
func TestTabSource(t *testing.T) {
	reader := csv.NewReader(bytes.NewBufferString(tabData))
	reader.Comma = '\t'
	table := NewWithCsvReader(reader)
	assert.Equal(t, expected, tests.GetRows(table))
	assert.Nil(t, table.Err())
}
Example #4
0
func TestGearmanSource(t *testing.T) {
	c := &mockClient{Mock: &mock.Mock{}, chans: []chan *packet.Packet{}}
	c.On("Submit", "function", []byte("workload"), mock.Anything, mock.Anything).Return(nil, nil).Once()
	numCalls := 0
	table := New(c, "function", []byte("workload"), func(in []byte) (optimus.Row, error) {
		numCalls++
		assert.Equal(t, in, []byte(fmt.Sprintf("%d", numCalls)))
		return optimus.Row{"field1": fmt.Sprintf("value%d", numCalls)}, nil
	})
	expected := []optimus.Row{
		{"field1": "value1"},
		{"field1": "value2"},
	}
	go func() {
		// Wait until a packet has been submitted
		for len(getChans(c)) == 0 {
			time.Sleep(time.Millisecond)
		}
		packets := getChans(c)[0]
		packets <- handlePacket("", packet.WorkData, [][]byte{[]byte("1")})
		packets <- handlePacket("", packet.WorkData, [][]byte{[]byte("2")})
		packets <- handlePacket("", packet.WorkComplete, nil)
	}()
	assert.Equal(t, expected, tests.GetRows(table))
	assert.Nil(t, table.Err())
}
Example #5
0
func TestJSONSource(t *testing.T) {
	table := New(bytes.NewBufferString(jsonData))
	expected := []optimus.Row{
		{"header1": "field1", "header2": "field2", "header3": "field3"},
		{"header1": "field4", "header2": "field5", "header3": "field6"},
		{"header1": "field7", "header2": "field8", "header3": "field9"},
	}
	assert.Equal(t, expected, tests.GetRows(table))
	assert.Nil(t, table.Err())
}
Example #6
0
func TestGearmanSourceFail(t *testing.T) {
	c := &mockClient{Mock: &mock.Mock{}, chans: []chan *packet.Packet{}}
	c.On("Submit", "function", []byte("workload"), mock.Anything, mock.Anything).Return(nil, nil).Once()
	table := New(c, "function", []byte("workload"), func(in []byte) (optimus.Row, error) {
		t.Fatal("never expected converter to be called")
		return nil, nil
	})
	go func() {
		packets := c.chans[0]
		packets <- handlePacket("", packet.WorkWarning, [][]byte{[]byte("1")})
		packets <- handlePacket("", packet.WorkFail, nil)
	}()
	expected := []optimus.Row{}
	assert.Equal(t, expected, tests.GetRows(table))
	assert.EqualError(t, table.Err(), "gearman job 'function' failed with warnings: 1")
}
Example #7
0
func TestSort(t *testing.T) {
	for _, sortTest := range sortTests {
		for _, sort := range []optimus.TransformFunc{Sort(sortTest.less), StableSort(sortTest.less)} {
			input := slice.New(sortTest.input)
			table := optimus.Transform(input, sort)

			actual := tests.GetRows(table)

			if sortTest.err != nil {
				assert.Equal(t, sortTest.err, table.Err())
			} else {
				assert.Equal(t, actual, sortTest.output)
				assert.Nil(t, table.Err())
			}
		}
	}
}
Example #8
0
func TestNilValues(t *testing.T) {
	rows := []optimus.Row{{"field1": "val1", "field2": nil}}
	actual := &bytes.Buffer{}
	assert.Nil(t, New(actual)(slice.New(rows)))
	assert.Equal(t, tests.GetRows(csv.New(actual)), rows)
}
Example #9
0
func TestCSVSource(t *testing.T) {
	table := New(bytes.NewBufferString(csvData))
	assert.Equal(t, expected, tests.GetRows(table))
	assert.Nil(t, table.Err())
}