Skip to content

Commit

Permalink
#232 Working testcases
Browse files Browse the repository at this point in the history
  • Loading branch information
@docktermj
docktermj committed Sep 11, 2024
1 parent 5d6f15f commit cdbbbf7
Show file tree
Hide file tree
Showing 2 changed files with 258 additions and 27 deletions.
7 changes: 2 additions & 5 deletions szdiagnostic/szdiagnostic_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -44,11 +44,8 @@ const (
// Nil/empty parameters

var (
nilSecondsToRun int
nilFeatureID int64
nilConfigDefinition string
nilConfigHandle uintptr
nilDataSourceCode string
nilSecondsToRun int
nilFeatureID int64
)

var (
Expand Down
278 changes: 256 additions & 22 deletions szengine/szengine_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,13 +9,9 @@ import (
"path/filepath"
"strconv"
"strings"
"syscall"
"testing"
"time"

"golang.org/x/text/language"
"golang.org/x/text/message"

truncator "github.com/aquilax/truncate"
"github.com/senzing-garage/go-helpers/fileutil"
"github.com/senzing-garage/go-helpers/record"
Expand Down Expand Up @@ -73,7 +69,6 @@ const (
var (
nilAttributes string
nilAvoidEntityIDs string
nilAvoidRecordKeys string
nilBuildOutDegrees int64
nilBuildOutMaxEntities int64
nilCsvColumnList string
Expand Down Expand Up @@ -1937,16 +1932,28 @@ func TestSzengine_HowEntityByEntityID_badEntityID(test *testing.T) {
printActual(test, actual)
}

func TestSzengine_HowEntityByEntityID_nilEntityID(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
flags := senzing.SzNoFlags
actual, err := szEngine.HowEntityByEntityID(ctx, nilEntityID, flags)
require.ErrorIs(test, err, szerror.ErrSzNotFound)
printActual(test, actual)
}

func TestSzengine_PrimeEngine(test *testing.T) {
ctx := context.TODO()
szEngine := getTestObject(ctx, test)
err := szEngine.PrimeEngine(ctx)
require.NoError(test, err)
}

// TODO: Implement TestSzengine_PrimeEngine_error
// func TestSzengine_PrimeEngine_error(test *testing.T) {}

func TestSzengine_ProcessRedoRecord(test *testing.T) {
ctx := context.TODO()
szEngine := getTestObject(ctx, test)
Expand All @@ -1969,6 +1976,15 @@ func TestSzengine_ProcessRedoRecord_badRedoRecord(test *testing.T) {
printActual(test, actual)
}

func TestSzengine_ProcessRedoRecord_nilRedoRecord(test *testing.T) {
ctx := context.TODO()
szEngine := getTestObject(ctx, test)
flags := senzing.SzWithoutInfo
actual, err := szEngine.ProcessRedoRecord(ctx, nilRedoRecord, flags)
require.ErrorIs(test, err, szerror.ErrSzBadInput)
printActual(test, actual)
}

func TestSzengine_ProcessRedoRecord_withInfo(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
Expand Down Expand Up @@ -2002,6 +2018,15 @@ func TestSzengine_ProcessRedoRecord_withInfo_badRedoRecord(test *testing.T) {
printActual(test, actual)
}

func TestSzengine_ProcessRedoRecord_withInfo_nilRedoRecord(test *testing.T) {
ctx := context.TODO()
szEngine := getTestObject(ctx, test)
flags := senzing.SzWithInfo
actual, err := szEngine.ProcessRedoRecord(ctx, nilRedoRecord, flags)
require.ErrorIs(test, err, szerror.ErrSzBadInput)
printActual(test, actual)
}

func TestSzengine_ReevaluateEntity(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
Expand Down Expand Up @@ -2034,8 +2059,20 @@ func TestSzengine_ReevaluateEntity_badEntityID(test *testing.T) {
printActual(test, actual)
}

// TODO: Implement TestSzengine_ReevaluateEntity_error
// func TestSzengine_ReevaluateEntity_error(test *testing.T) {}
func TestSzengine_ReevaluateEntity_nilEntityID(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
flags := senzing.SzWithoutInfo
actual, err := szEngine.ReevaluateEntity(ctx, nilEntityID, flags)
require.NoError(test, err)
printActual(test, actual)
}

func TestSzengine_ReevaluateEntity_withInfo(test *testing.T) {
ctx := context.TODO()
Expand Down Expand Up @@ -2069,8 +2106,20 @@ func TestSzengine_ReevaluateEntity_withInfo_badEntityID(test *testing.T) {
printActual(test, actual)
}

// TODO: Implement TestSzengine_ReevaluateEntity_withInfo_error
// func TestSzengine_ReevaluateEntity_withInfo_error(test *testing.T) {}
func TestSzengine_ReevaluateEntity_withInfo_nilEntityID(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
flags := senzing.SzWithInfo
actual, err := szEngine.ReevaluateEntity(ctx, nilEntityID, flags)
require.NoError(test, err)
printActual(test, actual)
}

func TestSzengine_ReevaluateRecord(test *testing.T) {
ctx := context.TODO()
Expand Down Expand Up @@ -2119,6 +2168,39 @@ func TestSzengine_ReevaluateRecord_badRecordID(test *testing.T) {
require.NoError(test, err)
printActual(test, actual)
}

func TestSzengine_ReevaluateRecord_nilDataSourceCode(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
record := truthset.CustomerRecords["1001"]
flags := senzing.SzWithoutInfo
actual, err := szEngine.ReevaluateRecord(ctx, nilDataSourceCode, record.ID, flags)
require.ErrorIs(test, err, szerror.ErrSzUnknownDataSource)
printActual(test, actual)
}

func TestSzengine_ReevaluateRecord_nilRecordID(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
record := truthset.CustomerRecords["1001"]
flags := senzing.SzWithoutInfo
actual, err := szEngine.ReevaluateRecord(ctx, record.DataSource, nilRecordID, flags)
require.NoError(test, err)
printActual(test, actual)
}

func TestSzengine_ReevaluateRecord_withInfo(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
Expand Down Expand Up @@ -2151,6 +2233,22 @@ func TestSzengine_ReevaluateRecord_withInfo_badDataSourceCode(test *testing.T) {
printActual(test, actual)
}

func TestSzengine_ReevaluateRecord_withInfo_nilDataSourceCode(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
record := truthset.CustomerRecords["1001"]
flags := senzing.SzWithInfo
actual, err := szEngine.ReevaluateRecord(ctx, nilDataSourceCode, record.ID, flags)
require.ErrorIs(test, err, szerror.ErrSzUnknownDataSource)
printActual(test, actual)
}

func TestSzengine_SearchByAttributes(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
Expand Down Expand Up @@ -2204,8 +2302,40 @@ func TestSzengine_SearchByAttributes_badSearchProfile(test *testing.T) {
printActual(test, actual)
}

// TODO: Implement TestSzengine_SearchByAttributes_error
// func TestSzengine_SearchByAttributes_error(test *testing.T) {}
func TestSzengine_SearchByAttributes_nilAttributes(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
truthset.CustomerRecords["1002"],
truthset.CustomerRecords["1003"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
flags := senzing.SzNoFlags
actual, err := szEngine.SearchByAttributes(ctx, nilAttributes, searchProfile, flags)
require.ErrorIs(test, err, szerror.ErrSz)
printActual(test, actual)
}

func TestSzengine_SearchByAttributes_nilSearchProfile(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
truthset.CustomerRecords["1002"],
truthset.CustomerRecords["1003"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
attributes := `{"NAMES": [{"NAME_TYPE": "PRIMARY", "NAME_LAST": "JOHNSON"}], "SSN_NUMBER": "053-39-3251"}`
flags := senzing.SzNoFlags
actual, err := szEngine.SearchByAttributes(ctx, attributes, nilSearchProfile, flags)
require.NoError(test, err)
printActual(test, actual)
}

func TestSzengine_SearchByAttributes_withSearchProfile(test *testing.T) {
ctx := context.TODO()
Expand Down Expand Up @@ -2298,6 +2428,42 @@ func TestSzengine_WhyEntities_badEnitity2(test *testing.T) {
printActual(test, actual)
}

func TestSzengine_WhyEntities_nilEnitity1(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
truthset.CustomerRecords["1002"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
entityID2, err := getEntityID(truthset.CustomerRecords["1002"])
require.NoError(test, err)
flags := senzing.SzNoFlags
actual, err := szEngine.WhyEntities(ctx, nilEntityID, entityID2, flags)
require.ErrorIs(test, err, szerror.ErrSzNotFound)
printActual(test, actual)
}

func TestSzengine_WhyEntities_nilEnitity2(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
truthset.CustomerRecords["1002"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
entityID1, err := getEntityID(truthset.CustomerRecords["1001"])
require.NoError(test, err)
flags := senzing.SzNoFlags
actual, err := szEngine.WhyEntities(ctx, entityID1, nilEntityID, flags)
require.ErrorIs(test, err, szerror.ErrSzNotFound)
printActual(test, actual)
}

func TestSzengine_WhyRecordInEntity(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
Expand Down Expand Up @@ -2346,6 +2512,38 @@ func TestSzengine_WhyRecordInEntity_badRecordID(test *testing.T) {
printActual(test, actual)
}

func TestSzengine_WhyRecordInEntity_nilDataSourceCode(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
record := truthset.CustomerRecords["1001"]
flags := senzing.SzNoFlags
actual, err := szEngine.WhyRecordInEntity(ctx, nilDataSourceCode, record.ID, flags)
require.ErrorIs(test, err, szerror.ErrSzUnknownDataSource)
printActual(test, actual)
}

func TestSzengine_WhyRecordInEntity_nilRecordID(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
record := truthset.CustomerRecords["1001"]
flags := senzing.SzNoFlags
actual, err := szEngine.WhyRecordInEntity(ctx, record.DataSource, nilRecordID, flags)
require.ErrorIs(test, err, szerror.ErrSzNotFound)
printActual(test, actual)
}

func TestSzengine_WhyRecords(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
Expand Down Expand Up @@ -2400,6 +2598,42 @@ func TestSzengine_WhyRecords_badRecordID(test *testing.T) {
printActual(test, actual)
}

func TestSzengine_WhyRecords_nilDataSourceCode(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
truthset.CustomerRecords["1002"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
record1 := truthset.CustomerRecords["1001"]
record2 := truthset.CustomerRecords["1002"]
flags := senzing.SzNoFlags
actual, err := szEngine.WhyRecords(ctx, nilDataSourceCode, record1.ID, record2.DataSource, record2.ID, flags)
require.ErrorIs(test, err, szerror.ErrSzUnknownDataSource)
printActual(test, actual)
}

func TestSzengine_WhyRecords_nilRecordID(test *testing.T) {
ctx := context.TODO()
records := []record.Record{
truthset.CustomerRecords["1001"],
truthset.CustomerRecords["1002"],
}
defer func() { handleError(deleteRecords(ctx, records)) }()
err := addRecords(ctx, records)
require.NoError(test, err)
szEngine := getTestObject(ctx, test)
record1 := truthset.CustomerRecords["1001"]
record2 := truthset.CustomerRecords["1002"]
flags := senzing.SzNoFlags
actual, err := szEngine.WhyRecords(ctx, record1.DataSource, record1.ID, record2.DataSource, nilRecordID, flags)
require.ErrorIs(test, err, szerror.ErrSzNotFound)
printActual(test, actual)
}

// ----------------------------------------------------------------------------
// Private methods
// ----------------------------------------------------------------------------
Expand Down Expand Up @@ -2713,14 +2947,14 @@ func printResult(test *testing.T, title string, result interface{}) {
}
}

func ramCheck(test *testing.T, iteration int) {
sysInfo := &syscall.Sysinfo_t{}
printer := message.NewPrinter(language.English)
err := syscall.Sysinfo(sysInfo)
require.NoError(test, err)
usedRAM := sysInfo.Totalram - sysInfo.Freeram
printer.Printf(">>> iteration: %d, Used memory: %d\n", iteration, usedRAM)
}
// func ramCheck(test *testing.T, iteration int) {
// sysInfo := &syscall.Sysinfo_t{}
// printer := message.NewPrinter(language.English)
// err := syscall.Sysinfo(sysInfo)
// require.NoError(test, err)
// usedRAM := sysInfo.Totalram - sysInfo.Freeram
// printer.Printf(">>> iteration: %d, Used memory: %d\n", iteration, usedRAM)
// }

func truncate(aString string, length int) string {
return truncator.Truncate(aString, length, "...", truncator.PositionEnd)
Expand Down

0 comments on commit cdbbbf7

Please sign in to comment.