Michael McGuinness
555b6d420b
Document Result Endpoint * testing * cleantesting * progress * query * lint * readme * dockerclient * api * passtest * tests * test
847 lines
26 KiB
Go
847 lines
26 KiB
Go
package repository_test
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path"
|
|
"testing"
|
|
|
|
"queryorchestration/internal/database/repository"
|
|
"queryorchestration/internal/serviceconfig"
|
|
"queryorchestration/internal/test"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestListClientDocumentIDs(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("Skipping long test in short mode")
|
|
}
|
|
ctx := context.Background()
|
|
|
|
cfg := &serviceconfig.BaseConfig{}
|
|
test.SetCfgProvider(t, cfg)
|
|
cfg.SetBasePath(path.Join(os.Getenv("PWD"), "../../.."))
|
|
_, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{
|
|
Cfg: cfg,
|
|
RunMigrations: true,
|
|
})
|
|
defer cleanup()
|
|
|
|
queries := cfg.GetDBQueries()
|
|
|
|
id, err := queries.CreateClient(ctx, &repository.CreateClientParams{
|
|
Name: "example_client",
|
|
Externalid: "EXAMPLE",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
ids, err := queries.ListDocumentIDsBatch(ctx, &repository.ListDocumentIDsBatchParams{
|
|
Clientid: id,
|
|
Batchsize: 1,
|
|
Pageoffset: 0,
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Len(t, ids, 0)
|
|
|
|
docOne, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
|
|
Clientid: id,
|
|
Hash: "example_hash",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
ids, err = queries.ListDocumentIDsBatch(ctx, &repository.ListDocumentIDsBatchParams{
|
|
Clientid: id,
|
|
Batchsize: 1,
|
|
Pageoffset: 0,
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Len(t, ids, 1)
|
|
total := int64(1)
|
|
assert.ElementsMatch(t, []*repository.ListDocumentIDsBatchRow{
|
|
{
|
|
ID: docOne,
|
|
Totalcount: &total,
|
|
},
|
|
}, ids)
|
|
|
|
docTwo, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
|
|
Clientid: id,
|
|
Hash: "example_hash_two",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
ids, err = queries.ListDocumentIDsBatch(ctx, &repository.ListDocumentIDsBatchParams{
|
|
Clientid: id,
|
|
Batchsize: 1,
|
|
Pageoffset: 0,
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Len(t, ids, 1)
|
|
total = int64(2)
|
|
assert.ElementsMatch(t, []*repository.ListDocumentIDsBatchRow{
|
|
{
|
|
ID: docOne,
|
|
Totalcount: &total,
|
|
},
|
|
}, ids)
|
|
|
|
ids, err = queries.ListDocumentIDsBatch(ctx, &repository.ListDocumentIDsBatchParams{
|
|
Clientid: id,
|
|
Batchsize: 1,
|
|
Pageoffset: 1,
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Len(t, ids, 1)
|
|
assert.ElementsMatch(t, []*repository.ListDocumentIDsBatchRow{
|
|
{
|
|
ID: docTwo,
|
|
Totalcount: &total,
|
|
},
|
|
}, ids)
|
|
|
|
ids, err = queries.ListDocumentIDsBatch(ctx, &repository.ListDocumentIDsBatchParams{
|
|
Clientid: id,
|
|
Batchsize: 2,
|
|
Pageoffset: 0,
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Len(t, ids, 2)
|
|
assert.ElementsMatch(t, []*repository.ListDocumentIDsBatchRow{
|
|
{
|
|
ID: docOne,
|
|
Totalcount: &total,
|
|
},
|
|
{
|
|
ID: docTwo,
|
|
Totalcount: &total,
|
|
},
|
|
}, ids)
|
|
}
|
|
|
|
func TestClientSync(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("Skipping long test in short mode")
|
|
}
|
|
ctx := context.Background()
|
|
|
|
cfg := &serviceconfig.BaseConfig{}
|
|
test.SetCfgProvider(t, cfg)
|
|
cfg.SetBasePath(path.Join(os.Getenv("PWD"), "../../.."))
|
|
_, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{
|
|
Cfg: cfg,
|
|
RunMigrations: true,
|
|
})
|
|
defer cleanup()
|
|
|
|
queries := cfg.GetDBQueries()
|
|
|
|
contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull))
|
|
assert.NoError(t, err)
|
|
contextQueryVersion, err := queries.AddLatestQueryVersion(ctx, contextQueryID)
|
|
assert.NoError(t, err)
|
|
err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
|
|
Queryid: contextQueryID,
|
|
Versionid: contextQueryVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
|
|
assert.NoError(t, err)
|
|
jsonQueryVersion, err := queries.AddLatestQueryVersion(ctx, jsonQueryID)
|
|
assert.NoError(t, err)
|
|
err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
|
|
Queryid: jsonQueryID,
|
|
Versionid: jsonQueryVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
|
|
Queryid: jsonQueryID,
|
|
Requiredqueryid: contextQueryID,
|
|
Addedversion: jsonQueryVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
externalId := "EXAMPLE"
|
|
clientId, err := queries.CreateClient(ctx, &repository.CreateClientParams{
|
|
Name: "example_client",
|
|
Externalid: externalId,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
collectorVersion, err := queries.AddLatestCollectorVersion(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
err = queries.SetActiveCollectorVersion(ctx, &repository.SetActiveCollectorVersionParams{
|
|
Versionid: collectorVersion,
|
|
Clientid: clientId,
|
|
})
|
|
assert.NoError(t, err)
|
|
err = queries.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{
|
|
Clientid: clientId,
|
|
Queryid: jsonQueryID,
|
|
Addedversion: collectorVersion,
|
|
Name: "first_key",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err := queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.True(t, isSynced)
|
|
|
|
bucket := "example_bucket"
|
|
|
|
t.Run("document fail clean", func(t *testing.T) {
|
|
documentID, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
|
|
Clientid: clientId,
|
|
Hash: "example_noclean",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
docExternal, err := queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_noclean",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
|
|
cleanid, err := queries.AddDocumentClean(ctx, &repository.AddDocumentCleanParams{
|
|
Documentid: documentID,
|
|
Fail: repository.NullCleanfailtype{
|
|
Valid: true,
|
|
Cleanfailtype: repository.CleanfailtypeInvalidMimetype,
|
|
},
|
|
})
|
|
assert.NoError(t, err)
|
|
err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
|
|
Cleanid: cleanid,
|
|
Version: 1,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.True(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_noclean",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
})
|
|
|
|
t.Run("valid extraction", func(t *testing.T) {
|
|
documentID, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{
|
|
Clientid: clientId,
|
|
Hash: "example_hash",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
|
|
docExternal, err := queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
key := "example_key"
|
|
cleanId, err := queries.AddDocumentClean(ctx, &repository.AddDocumentCleanParams{
|
|
Documentid: documentID,
|
|
Bucket: &bucket,
|
|
Key: &key,
|
|
Mimetype: repository.NullCleanmimetype{
|
|
Valid: true,
|
|
Cleanmimetype: repository.CleanmimetypeApplicationPdf,
|
|
},
|
|
})
|
|
assert.NoError(t, err)
|
|
err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
|
|
Cleanid: cleanId,
|
|
Version: 1,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
textId, err := queries.AddDocumentTextEntry(ctx, &repository.AddDocumentTextEntryParams{
|
|
Version: 1,
|
|
Bucket: "hi",
|
|
Key: "hello",
|
|
Cleanentryid: cleanId,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
t.Run("document standard results", func(t *testing.T) {
|
|
contextResultId, err := queries.AddResult(ctx, &repository.AddResultParams{
|
|
Queryid: contextQueryID,
|
|
Value: "example_context",
|
|
Textentryid: textId,
|
|
Queryversion: contextQueryVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
jsonResultId, err := queries.AddResult(ctx, &repository.AddResultParams{
|
|
Queryid: jsonQueryID,
|
|
Value: "json_value",
|
|
Textentryid: textId,
|
|
Queryversion: jsonQueryVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
err = queries.AddResultDependency(ctx, &repository.AddResultDependencyParams{
|
|
Resultid: jsonResultId,
|
|
Requiredresultid: contextResultId,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.True(t, isSynced)
|
|
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": "json_value"}`),
|
|
}, docExternal)
|
|
})
|
|
|
|
contextLatestVersion, err := queries.AddLatestQueryVersion(ctx, contextQueryID)
|
|
assert.NoError(t, err)
|
|
err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
|
|
Queryid: contextQueryID,
|
|
Versionid: contextLatestVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
t.Run("update upstream query", func(t *testing.T) {
|
|
contextResultId, err := queries.AddResult(ctx, &repository.AddResultParams{
|
|
Queryid: contextQueryID,
|
|
Value: "context_version_2",
|
|
Textentryid: textId,
|
|
Queryversion: contextLatestVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
jsonResultId, err := queries.AddResult(ctx, &repository.AddResultParams{
|
|
Queryid: jsonQueryID,
|
|
Value: "updated_context_value",
|
|
Textentryid: textId,
|
|
Queryversion: jsonQueryVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
err = queries.AddResultDependency(ctx, &repository.AddResultDependencyParams{
|
|
Resultid: jsonResultId,
|
|
Requiredresultid: contextResultId,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.True(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": "updated_context_value"}`),
|
|
}, docExternal)
|
|
})
|
|
|
|
t.Run("update text entry", func(t *testing.T) {
|
|
textId, err := queries.AddDocumentTextEntry(ctx, &repository.AddDocumentTextEntryParams{
|
|
Version: 1,
|
|
Bucket: "hi",
|
|
Key: "hello",
|
|
Cleanentryid: cleanId,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
contextResultID, err := queries.AddResult(ctx, &repository.AddResultParams{
|
|
Queryid: contextQueryID,
|
|
Value: "updated_text_context",
|
|
Textentryid: textId,
|
|
Queryversion: 2,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
jsonResultID, err := queries.AddResult(ctx, &repository.AddResultParams{
|
|
Queryid: jsonQueryID,
|
|
Value: "updated_text_json",
|
|
Textentryid: textId,
|
|
Queryversion: 1,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
err = queries.AddResultDependency(ctx, &repository.AddResultDependencyParams{
|
|
Resultid: jsonResultID,
|
|
Requiredresultid: contextResultID,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.True(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": "updated_text_json"}`),
|
|
}, docExternal)
|
|
})
|
|
t.Run("updated clean entry", func(t *testing.T) {
|
|
cleanthreeid, err := queries.AddDocumentClean(ctx, &repository.AddDocumentCleanParams{
|
|
Documentid: documentID,
|
|
Bucket: &bucket,
|
|
Key: &key,
|
|
Mimetype: repository.NullCleanmimetype{
|
|
Valid: true,
|
|
Cleanmimetype: repository.CleanmimetypeApplicationPdf,
|
|
},
|
|
})
|
|
assert.NoError(t, err)
|
|
err = queries.AddDocumentCleanEntry(ctx, &repository.AddDocumentCleanEntryParams{
|
|
Cleanid: cleanthreeid,
|
|
Version: 1,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
textThreeId, err := queries.AddDocumentTextEntry(ctx, &repository.AddDocumentTextEntryParams{
|
|
Version: 1,
|
|
Bucket: "hi",
|
|
Key: "hello",
|
|
Cleanentryid: cleanthreeid,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
contextResultId, err := queries.AddResult(ctx, &repository.AddResultParams{
|
|
Queryid: contextQueryID,
|
|
Value: "update_clean_context",
|
|
Textentryid: textThreeId,
|
|
Queryversion: contextLatestVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
jsonResultID, err := queries.AddResult(ctx, &repository.AddResultParams{
|
|
Queryid: jsonQueryID,
|
|
Value: "update_clean_json",
|
|
Textentryid: textThreeId,
|
|
Queryversion: 1,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": null}`),
|
|
}, docExternal)
|
|
|
|
err = queries.AddResultDependency(ctx, &repository.AddResultDependencyParams{
|
|
Resultid: jsonResultID,
|
|
Requiredresultid: contextResultId,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.True(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": "update_clean_json"}`),
|
|
}, docExternal)
|
|
|
|
latestCollectorVersion, err := queries.AddLatestCollectorVersion(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.True(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": "update_clean_json"}`),
|
|
}, docExternal)
|
|
|
|
t.Run("update collector name", func(t *testing.T) {
|
|
err = queries.SetActiveCollectorVersion(ctx, &repository.SetActiveCollectorVersionParams{
|
|
Versionid: latestCollectorVersion,
|
|
Clientid: clientId,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.True(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"first_key": "update_clean_json"}`),
|
|
}, docExternal)
|
|
|
|
err = queries.RemoveCollectorQuery(ctx, &repository.RemoveCollectorQueryParams{
|
|
Clientid: clientId,
|
|
Queryid: jsonQueryID,
|
|
Removedversion: &latestCollectorVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.True(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{}`),
|
|
}, docExternal)
|
|
|
|
err = queries.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{
|
|
Clientid: clientId,
|
|
Queryid: jsonQueryID,
|
|
Addedversion: latestCollectorVersion,
|
|
Name: "second_key",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.True(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"second_key": "update_clean_json"}`),
|
|
}, docExternal)
|
|
})
|
|
|
|
t.Run("add existing query", func(t *testing.T) {
|
|
err = queries.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{
|
|
Clientid: clientId,
|
|
Queryid: contextQueryID,
|
|
Addedversion: latestCollectorVersion,
|
|
Name: "example_key",
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.True(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"second_key": "update_clean_json", "example_key": "update_clean_context"}`),
|
|
}, docExternal)
|
|
})
|
|
|
|
t.Run("add super query", func(t *testing.T) {
|
|
superQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor))
|
|
assert.NoError(t, err)
|
|
superQueryVersion, err := queries.AddLatestQueryVersion(ctx, superQueryID)
|
|
assert.NoError(t, err)
|
|
err = queries.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
|
|
Queryid: superQueryID,
|
|
Versionid: superQueryVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
|
|
Queryid: contextQueryID,
|
|
Requiredqueryid: superQueryID,
|
|
Addedversion: superQueryVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
superResultId, err := queries.AddResult(ctx, &repository.AddResultParams{
|
|
Queryid: superQueryID,
|
|
Value: "super_value",
|
|
Textentryid: textThreeId,
|
|
Queryversion: superQueryVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"second_key": null, "example_key": null}`),
|
|
}, docExternal)
|
|
|
|
contextResultId, err := queries.AddResult(ctx, &repository.AddResultParams{
|
|
Queryid: contextQueryID,
|
|
Value: "context_with_super_value",
|
|
Textentryid: textThreeId,
|
|
Queryversion: contextLatestVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"second_key": null, "example_key": null}`),
|
|
}, docExternal)
|
|
|
|
jsonResultId, err := queries.AddResult(ctx, &repository.AddResultParams{
|
|
Queryid: jsonQueryID,
|
|
Value: "json_with_super",
|
|
Textentryid: textThreeId,
|
|
Queryversion: jsonQueryVersion,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"second_key": null, "example_key": null}`),
|
|
}, docExternal)
|
|
|
|
err = queries.AddResultDependency(ctx, &repository.AddResultDependencyParams{
|
|
Resultid: contextResultId,
|
|
Requiredresultid: superResultId,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.False(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"second_key": null, "example_key": "context_with_super_value"}`),
|
|
}, docExternal)
|
|
|
|
err = queries.AddResultDependency(ctx, &repository.AddResultDependencyParams{
|
|
Resultid: jsonResultId,
|
|
Requiredresultid: contextResultId,
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
isSynced, err = queries.IsClientSynced(ctx, clientId)
|
|
assert.NoError(t, err)
|
|
assert.True(t, isSynced)
|
|
docExternal, err = queries.GetDocumentExternal(ctx, documentID)
|
|
assert.NoError(t, err)
|
|
assert.EqualExportedValues(t, &repository.GetDocumentExternalRow{
|
|
ID: documentID,
|
|
Clientid: externalId,
|
|
Hash: "example_hash",
|
|
Fields: []byte(`{"second_key": "json_with_super", "example_key": "context_with_super_value"}`),
|
|
}, docExternal)
|
|
})
|
|
})
|
|
})
|
|
}
|