func messagePartitionWriter(a *assert.Assertions, store *messagePartition, n int, done chan bool) {
for i := 1; i <= n; i++ {
msg := []byte("Hello " + strconv.Itoa(i))
a.NoError(store.Store(uint64(i), msg))
}
done <- true
}
func writeJSONToService(service baseftrwapp.Service, pathToJSONFile string, assert *assert.Assertions) {
f, err := os.Open(pathToJSONFile)
assert.NoError(err)
dec := json.NewDecoder(f)
inst, _, errr := service.DecodeJSON(dec)
assert.NoError(errr)
errrr := service.Write(inst)
assert.NoError(errrr)
}
func writeJSONToService(service annotations.Service, pathToJSONFile string, contentUUID string, assert *assert.Assertions) {
f, err := os.Open(pathToJSONFile)
assert.NoError(err)
dec := json.NewDecoder(f)
annotation, errr := service.DecodeJSON(dec)
assert.NoError(errr)
errrr := service.Write(contentUUID, annotation)
assert.NoError(errrr)
}
func getServices(t *testing.T, assert *assert.Assertions, db neoutils.NeoConnection) (baseftrwapp.Service, baseftrwapp.Service, baseftrwapp.Service, baseftrwapp.Service, baseftrwapp.Service) {
peopleRW := people.NewCypherPeopleService(db)
assert.NoError(peopleRW.Initialise())
organisationRW := organisations.NewCypherOrganisationService(db)
assert.NoError(organisationRW.Initialise())
membershipsRW := memberships.NewCypherMembershipService(db)
assert.NoError(membershipsRW.Initialise())
rolesRW := roles.NewCypherDriver(db)
assert.NoError(rolesRW.Initialise())
financialInstrumentsRW := financialinstruments.NewCypherFinancialInstrumentService(db)
assert.NoError(financialInstrumentsRW.Initialise())
return peopleRW, organisationRW, membershipsRW, rolesRW, financialInstrumentsRW
}
func newTestableProvisioner(assert *assert.Assertions, options volume.VolumeOptions) volume.Provisioner {
tmpDir, err := utiltesting.MkTmpdir("flockervolumeTest")
assert.NoError(err, fmt.Sprintf("can't make a temp dir: %v", err))
plugMgr := volume.VolumePluginMgr{}
plugMgr.InitPlugins(ProbeVolumePlugins(), volumetest.NewFakeVolumeHost(tmpDir, nil, nil))
plug, err := plugMgr.FindPluginByName(pluginName)
assert.NoError(err, "Can't find the plugin by name")
provisioner, err := plug.(*flockerPlugin).newProvisionerInternal(options, &fakeFlockerUtil{})
return provisioner
}
func readDocument(a *assert.Assertions, file string) Document {
var document Document
out, err := ioutil.ReadFile(file)
a.NoError(err)
err = yaml.Unmarshal(out, &document.stack)
a.NoError(err)
a.NotEmpty(document.stack)
return document
}
func writeClassifedByRelationship(db neoutils.NeoConnection, contentId string, conceptId string, lifecycle string, t *testing.T, assert *assert.Assertions) {
var annotateQuery string
var qs []*neoism.CypherQuery
if lifecycle == "" {
annotateQuery = `
MERGE (content:Thing{uuid:{contentId}})
MERGE (upp:Identifier:UPPIdentifier{value:{conceptId}})
MERGE (upp)-[:IDENTIFIES]->(concept:Thing) ON CREATE SET concept.uuid = {conceptId}
MERGE (content)-[pred:IS_CLASSIFIED_BY {platformVersion:'v1'}]->(concept)
`
qs = []*neoism.CypherQuery{
{
Statement: annotateQuery,
Parameters: neoism.Props{"contentId": contentId, "conceptId": conceptId},
},
}
} else {
annotateQuery = `
MERGE (content:Thing{uuid:{contentId}})
MERGE (upp:Identifier:UPPIdentifier{value:{conceptId}})
MERGE (upp)-[:IDENTIFIES]->(concept:Thing) ON CREATE SET concept.uuid = {conceptId}
MERGE (content)-[pred:IS_CLASSIFIED_BY {platformVersion:'v1', lifecycle: {lifecycle}}]->(concept)
`
qs = []*neoism.CypherQuery{
{
Statement: annotateQuery,
Parameters: neoism.Props{"contentId": contentId, "conceptId": conceptId, "lifecycle": lifecycle},
},
}
}
err := db.CypherBatch(qs)
assert.NoError(err)
}
func assertMetrics(a *assert.Assertions, s *service.Service, expected expectedValues) {
httpClient := &http.Client{}
u := fmt.Sprintf("http://%s%s", s.WebServer().GetAddr(), defaultMetricsEndpoint)
request, err := http.NewRequest(http.MethodGet, u, nil)
a.NoError(err)
response, err := httpClient.Do(request)
a.NoError(err)
defer response.Body.Close()
a.Equal(http.StatusOK, response.StatusCode)
bodyBytes, err := ioutil.ReadAll(response.Body)
a.NoError(err)
logger.WithField("body", string(bodyBytes)).Debug("metrics response")
mFCM := &fcmMetrics{}
err = json.Unmarshal(bodyBytes, mFCM)
a.NoError(err)
a.Equal(0, mFCM.TotalSentMessageErrors)
a.Equal(expected.MessageCount, mFCM.TotalSentMessages)
a.Equal(0, mFCM.Minute.CurrentErrorsCount)
a.Equal(expected.MessageCount, mFCM.Minute.CurrentMessagesCount)
a.Equal(0, mFCM.Minute.CurrentErrorsTotalLatencies)
a.Equal(expected.ZeroLatencies, mFCM.Minute.CurrentMessagesTotalLatencies == 0)
a.Equal(0, mFCM.Hour.CurrentErrorsCount)
a.Equal(expected.MessageCount, mFCM.Hour.CurrentMessagesCount)
a.Equal(0, mFCM.Hour.CurrentErrorsTotalLatencies)
a.Equal(expected.ZeroLatencies, mFCM.Hour.CurrentMessagesTotalLatencies == 0)
a.Equal(0, mFCM.Day.CurrentErrorsCount)
a.Equal(expected.MessageCount, mFCM.Day.CurrentMessagesCount)
a.Equal(0, mFCM.Day.CurrentErrorsTotalLatencies)
a.Equal(expected.ZeroLatencies, mFCM.Day.CurrentMessagesTotalLatencies == 0)
mRouter := &routerMetrics{}
err = json.Unmarshal(bodyBytes, mRouter)
a.NoError(err)
a.Equal(expected.CurrentRoutes, mRouter.CurrentRoutes)
a.Equal(expected.CurrentSubscriptions, mRouter.CurrentSubscriptions)
}
func cleanDB(db neoutils.CypherRunner, t *testing.T, assert *assert.Assertions, uuidsToClean []string) {
qs := []*neoism.CypherQuery{}
for _, uuid := range uuidsToClean {
qs = append(qs, &neoism.CypherQuery{Statement: fmt.Sprintf("MATCH (org:Thing {uuid: '%v'})<-[:IDENTIFIES*0..]-(i:Identifier) DETACH DELETE org, i", uuid)})
qs = append(qs, &neoism.CypherQuery{Statement: fmt.Sprintf("MATCH (org:Thing {uuid: '%v'}) DETACH DELETE org", uuid)})
}
err := db.CypherBatch(qs)
assert.NoError(err)
}
func getDatabaseConnection(assert *assert.Assertions) neoutils.NeoConnection {
url := os.Getenv("NEO4J_TEST_URL")
if url == "" {
url = "http://localhost:7474/db/data"
}
conf := neoutils.DefaultConnectionConfig()
conf.Transactional = false
db, err := neoutils.Connect(url, conf)
assert.NoError(err, "Failed to connect to Neo4j")
return db
}
func testByteRange(assert *assert.Assertions, offset, length int64, expect io.ReadSeeker, actual io.ReadSeeker) {
n, err := expect.Seek(offset, 0)
assert.Equal(offset, n)
assert.NoError(err)
b1 := &bytes.Buffer{}
n, err = io.CopyN(b1, expect, length)
assert.Equal(length, n)
assert.NoError(err)
n, err = actual.Seek(offset, 0)
assert.Equal(offset, n)
assert.NoError(err)
b2 := &bytes.Buffer{}
n, err = io.CopyN(b2, actual, length)
assert.Equal(length, n)
assert.NoError(err)
assert.Equal(b1.Bytes(), b2.Bytes())
}
func cleanDB(db neoutils.CypherRunner, t *testing.T, assert *assert.Assertions) {
qs := []*neoism.CypherQuery{
{
Statement: fmt.Sprintf("MATCH (mc:Thing {uuid: '%v'}) DETACH DELETE mc", minimalContentUuid),
},
{
Statement: fmt.Sprintf("MATCH (fc:Thing {uuid: '%v'}) DETACH DELETE fc", fullContentUuid),
},
}
err := db.CypherBatch(qs)
assert.NoError(err)
}
func cleanRelationshipDB(db neoutils.CypherRunner, t *testing.T, assert *assert.Assertions, uuidsToClean []string) {
cleanDB(db, t, assert, uuidsToClean)
qs := []*neoism.CypherQuery{
{
Statement: fmt.Sprintf("MATCH (c:Content {uuid: '%v'})-[rel]-(o) DELETE c, rel ", relationShipTransferContentUUID),
},
{
Statement: fmt.Sprintf("MATCH (c:Content {uuid: '%v'}) DELETE c ", relationShipTransferContentUUID),
},
}
err := db.CypherBatch(qs)
assert.NoError(err)
}
func mockGetStateNodes(assert *assert.Assertions, data []byte) *Client {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
assert.Equal("GET", r.Method)
assert.Equal("/v1/state/nodes", r.URL.Path)
w.Write(data)
}))
host, port, err := getHostAndPortFromTestServer(ts)
assert.NoError(err)
c := newFlockerTestClient(host, port)
return c
}
func deleteAllViaService(db neoutils.CypherRunner, assert *assert.Assertions, annotationsRW annotations.Service) {
_, err := annotationsRW.Delete(contentUUID)
assert.Nil(err)
qs := []*neoism.CypherQuery{
{
Statement: fmt.Sprintf("MATCH (c:Thing {uuid: '%v'})-[rel]-(o) DELETE c, rel ", contentUUID),
},
{
Statement: fmt.Sprintf("MATCH (c:Thing {uuid: '%v'}) DELETE c ", contentUUID),
},
}
err = db.CypherBatch(qs)
assert.NoError(err)
}
func checkRelationship(assert *assert.Assertions, contentID string, platformVersion string) {
countQuery := `Match (t:Thing {uuid: {contentID}})-[r {lifecycle: {lifecycle}}]-(x) return count(r) as c`
results := []struct {
Count int `json:"c"`
}{}
qs := &neoism.CypherQuery{
Statement: countQuery,
Parameters: neoism.Props{"contentID": contentID, "lifecycle": "annotations-" + platformVersion},
Result: &results,
}
err := annotationsDriver.conn.CypherBatch([]*neoism.CypherQuery{qs})
assert.NoError(err)
assert.Equal(1, len(results), "More results found than expected!")
assert.Equal(1, results[0].Count, "No Relationship with Lifecycle found!")
}
func checkClassifedByRelationship(db neoutils.NeoConnection, conceptId string, lifecycle string, t *testing.T, assert *assert.Assertions) int {
countQuery := ` MATCH (t:Thing{uuid:{conceptId}})-[r:IS_CLASSIFIED_BY {platformVersion:'v1', lifecycle: {lifecycle}}]-(x)
MATCH (t)<-[:IDENTIFIES]-(s:Identifier:UPPIdentifier)
RETURN count(r) as c`
results := []struct {
Count int `json:"c"`
}{}
qs := &neoism.CypherQuery{
Statement: countQuery,
Parameters: neoism.Props{"conceptId": conceptId, "lifecycle": lifecycle},
Result: &results,
}
err := db.CypherBatch([]*neoism.CypherQuery{qs})
assert.NoError(err)
return results[0].Count
}
func cleanDB(t *testing.T, assert *assert.Assertions) {
annotationsDriver = getAnnotationsService(t, v2PlatformVersion)
qs := []*neoism.CypherQuery{
{
Statement: fmt.Sprintf("MATCH (mc:Thing {uuid: '%v'}) DETACH DELETE mc", contentUUID),
},
{
Statement: fmt.Sprintf("MATCH (fc:Thing {uuid: '%v'}) DETACH DELETE fc", conceptUUID),
},
{
Statement: fmt.Sprintf("MATCH (fc:Thing {uuid: '%v'}) DETACH DELETE fc", secondConceptUUID),
},
{
Statement: fmt.Sprintf("MATCH (fc:Thing {uuid: '%v'}) DETACH DELETE fc", oldConceptUUID),
},
{
Statement: fmt.Sprintf("MATCH (fc:Thing {uuid: '%v'}) DETACH DELETE fc", brandUUID),
},
}
err := annotationsDriver.conn.CypherBatch(qs)
assert.NoError(err)
}
func assertGetNoExist(a *assert.Assertions, s KVStore, schema string, key string) {
val, exist, err := s.Get(schema, key)
a.NoError(err)
a.False(exist)
a.Nil(val)
}
func assertGet(a *assert.Assertions, s KVStore, schema string, key string, expectedValue []byte) {
val, exist, err := s.Get(schema, key)
a.NoError(err)
a.True(exist)
a.Equal(expectedValue, val)
}
func deleteFinancialInstrumentViaService(assert *assert.Assertions, financialInstrument baseftrwapp.Service, uuid string) {
_, err := financialInstrument.Delete(uuid)
assert.NoError(err)
}
func cleanDB(db neoutils.NeoConnection, t *testing.T, assert *assert.Assertions) {
qs := []*neoism.CypherQuery{
{
Statement: fmt.Sprintf("MATCH (a:Thing {uuid: '%v'}) DETACH DELETE a", "f21a5cc0-d326-4e62-b84a-d840c2209fee"),
},
{
Statement: fmt.Sprintf("MATCH (b:Thing {uuid: '%v'}) DETACH DELETE b", "84cec0e1-a866-47bd-9444-d74873b69786"),
},
{
Statement: fmt.Sprintf("MATCH (c:Thing {uuid: '%v'}) DETACH DELETE c", "fa2ae871-ef77-49c8-a030-8d90eae6cf18"),
},
{
Statement: fmt.Sprintf("MATCH (d:Thing {uuid: '%v'}) DETACH DELETE d", "868c3c17-611c-4943-9499-600ccded71f3"),
},
{
Statement: fmt.Sprintf("MATCH (e:Thing {uuid: '%v'}) DETACH DELETE e", "d8bbba91-8a87-4dee-bd1a-f79e8139e5c9"),
},
{
Statement: fmt.Sprintf("MATCH (f:Thing {uuid: '%v'}) DETACH DELETE f", "c7063a20-5ca5-4f7a-8a96-47e946b5739e"),
},
{
Statement: fmt.Sprintf("MATCH (g:Thing {uuid: '%v'}) DETACH DELETE g", "ff9e35f2-63e4-487a-87a4-d82535e047de"),
},
{
Statement: fmt.Sprintf("MATCH (h:Thing {uuid: '%v'}) DETACH DELETE h", "177de04f-c09a-4d66-ab55-bb68496c9c28"),
},
{
Statement: fmt.Sprintf("MATCH (i:Thing {uuid: '%v'}) DETACH DELETE i", "6b278d36-5b30-46a3-b036-55902a9d31ac"),
},
{
Statement: fmt.Sprintf("MATCH (j:Thing {uuid: '%v'}) DETACH DELETE j", "c739b972-f41d-43d2-b8d9-5848c92e17f6"),
},
{
Statement: fmt.Sprintf("MATCH (k:Thing {uuid: '%v'}) DETACH DELETE k", "668c103f-d8dc-4938-9324-9c60de726705"),
},
{
Statement: fmt.Sprintf("MATCH (l:Thing {uuid: '%v'}) DETACH DELETE l", "f21a5cc0-d326-4e62-b84a-d840c2209fee"),
},
{
Statement: fmt.Sprintf("MATCH (m:Thing {uuid: '%v'}) DETACH DELETE m", "bdacd96e-d2f4-429f-bb61-462e40448409"),
},
{
Statement: fmt.Sprintf("MATCH (n:Thing {uuid: '%v'}) DETACH DELETE n", "9c50e77a-de8a-4f8c-b1dd-09c7730e2c70"),
},
{
Statement: fmt.Sprintf("MATCH (o:Thing {uuid: '%v'}) DETACH DELETE o", "5fcfec9c-8ff0-4ee2-9e91-f270492d636c"),
},
{
//deletes parent 'org' which only has type Thing
Statement: fmt.Sprintf("MATCH (p:Thing {uuid: '%v'}) DETACH DELETE p", "3e844449-b27f-40d4-b696-2ce9b6137133"),
},
{
//deletes upp identifier for the above parent 'org'
Statement: fmt.Sprintf("MATCH (q:Identifier {value: '%v'}) DETACH DELETE q", "3e844449-b27f-40d4-b696-2ce9b6137133"),
},
{
//deletes parent 'org' which only has type Thing
Statement: fmt.Sprintf("MATCH (r:Thing {uuid: '%v'}) DETACH DELETE r", "f9694ba7-eab0-4ce0-8e01-ff64bccb813c"),
},
{
//deletes upp identifier for the above parent 'org'
Statement: fmt.Sprintf("MATCH (s:Identifier {value: '%v'}) DETACH DELETE s", "f9694ba7-eab0-4ce0-8e01-ff64bccb813c"),
},
}
err := db.CypherBatch(qs)
assert.NoError(err)
}
