uber / cadence / 0187fdd2-f4a4-4c9a-97b4-6604937bf7be

coverage: 57.253% (-0.002%) from 57.255%
0187fdd2-f4a4-4c9a-97b4-6604937bf7be

Pull #5252

buildkite

David Porter 
Merge branch 'master' into feature/zonal-partitioning
Pull Request #5252: Feature/zonal partitioning

1460 of 1460 new or added lines in 51 files covered. (100.0%)

86909 of 151799 relevant lines covered (57.25%)

2482.17 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0
/common/persistence/persistence-tests/metadataPersistenceV2Test.go
1 
// Copyright (c) 2017 Uber Technologies, Inc.
2 
//
3 
// Permission is hereby granted, free of charge, to any person obtaining a copy
4 
// of this software and associated documentation files (the "Software"), to deal
5 
// in the Software without restriction, including without limitation the rights
6 
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 
// copies of the Software, and to permit persons to whom the Software is
8 
// furnished to do so, subject to the following conditions:
9 
//
10 
// The above copyright notice and this permission notice shall be included in
11 
// all copies or substantial portions of the Software.
12 
//
13 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 
// THE SOFTWARE.
20 









21



package persistencetests










22












23



import (










24



        "context"










25



        "fmt"










26



        "os"










27



        "strconv"










28



        "strings"










29



        "sync"










30



        "sync/atomic"










31



        "testing"










32



        "time"










33












34



        "github.com/pborman/uuid"










35



        log "github.com/sirupsen/logrus"










36



        "github.com/stretchr/testify/require"










37












38



        "github.com/uber/cadence/common"










39



        "github.com/uber/cadence/common/cluster"










40



        p "github.com/uber/cadence/common/persistence"










41



        "github.com/uber/cadence/common/types"










42



)










43












44



type (










45



        // MetadataPersistenceSuiteV2 is test of the V2 version of metadata persistence










46



        MetadataPersistenceSuiteV2 struct {










47



                TestBase










48



                // override suite.Suite.Assertions with require.Assertions; this means that s.NotNil(nil) will stop the test,










49



                // not merely log an error










50



                *require.Assertions










51



        }










52



)










53












54



// SetupSuite implementation










55



func (m *MetadataPersistenceSuiteV2) SetupSuite() {




×







56



        if testing.Verbose() {




×







57



                log.SetOutput(os.Stdout)




×







58



        }




×







59



}










60












61



// SetupTest implementation










62



func (m *MetadataPersistenceSuiteV2) SetupTest() {




×







63



        // Have to define our overridden assertions in the test setup. If we did it earlier, s.T() will return nil




×







64



        m.Assertions = require.New(m.T())




×







65






×







66



        // cleanup the domain created




×







67



        var token []byte




×







68



        pageSize := 10




×







69



ListLoop:




×







70



        for {




×







71



                resp, err := m.ListDomains(context.Background(), pageSize, token)




×







72



                m.NoError(err)




×







73



                token = resp.NextPageToken




×







74



                for _, domain := range resp.Domains {




×







75



                        m.NoError(m.DeleteDomain(context.Background(), domain.Info.ID, ""))




×







76



                }




×







77



                if len(token) == 0 {




×







78



                        break ListLoop




×







79



                }










80



        }










81



}










82












83



// TearDownTest implementation










84



func (m *MetadataPersistenceSuiteV2) TearDownTest() {




×







85



}




×







86












87



// TearDownSuite implementation










88



func (m *MetadataPersistenceSuiteV2) TearDownSuite() {




×







89



        m.TearDownWorkflowStore()




×







90



}




×







91












92



// TestCreateDomain test










93



func (m *MetadataPersistenceSuiteV2) TestCreateDomain() {




×







94



        ctx, cancel := context.WithTimeout(context.Background(), testContextTimeout)




×







95



        defer cancel()




×







96






×







97



        id := uuid.New()




×







98



        name := "create-domain-test-name"




×







99



        status := p.DomainStatusRegistered




×







100



        description := "create-domain-test-description"




×







101



        owner := "create-domain-test-owner"




×







102



        data := map[string]string{"k1": "v1"}




×







103



        retention := int32(10)




×







104



        emitMetric := true




×







105



        historyArchivalStatus := types.ArchivalStatusEnabled




×







106



        historyArchivalURI := "test://history/uri"




×







107



        visibilityArchivalStatus := types.ArchivalStatusEnabled




×







108



        visibilityArchivalURI := "test://visibility/uri"




×







109



        badBinaries := types.BadBinaries{map[string]*types.BadBinaryInfo{}}




×







110



        isGlobalDomain := false




×







111



        configVersion := int64(0)




×







112



        failoverVersion := int64(0)




×







113



        lastUpdateTime := int64(100)




×







114






×







115



        resp0, err0 := m.CreateDomain(




×







116



                ctx,




×







117



                &p.DomainInfo{




×







118



                        ID:          id,




×







119



                        Name:        name,




×







120



                        Status:      status,




×







121



                        Description: description,




×







122



                        OwnerEmail:  owner,




×







123



                        Data:        data,




×







124



                },




×







125



                &p.DomainConfig{




×







126



                        Retention:                retention,




×







127



                        EmitMetric:               emitMetric,




×







128



                        HistoryArchivalStatus:    historyArchivalStatus,




×







129



                        HistoryArchivalURI:       historyArchivalURI,




×







130



                        VisibilityArchivalStatus: visibilityArchivalStatus,




×







131



                        VisibilityArchivalURI:    visibilityArchivalURI,




×







132



                        BadBinaries:              badBinaries,




×







133



                },




×







134



                &p.DomainReplicationConfig{},




×







135



                isGlobalDomain,




×







136



                configVersion,




×







137



                failoverVersion,




×







138



                lastUpdateTime,




×







139



        )




×







140



        m.NoError(err0)




×







141



        m.NotNil(resp0)




×







142



        m.Equal(id, resp0.ID)




×







143






×







144



        // for domain which do not have replication config set, will default to




×







145



        // use current cluster as active, with current cluster as all clusters




×







146



        resp1, err1 := m.GetDomain(ctx, id, "")




×







147



        m.NoError(err1)




×







148



        m.NotNil(resp1)




×







149



        m.Equal(id, resp1.Info.ID)




×







150



        m.Equal(name, resp1.Info.Name)




×







151



        m.Equal(status, resp1.Info.Status)




×







152



        m.Equal(description, resp1.Info.Description)




×







153



        m.Equal(owner, resp1.Info.OwnerEmail)




×







154



        m.Equal(data, resp1.Info.Data)




×







155



        m.Equal(retention, resp1.Config.Retention)




×







156



        m.Equal(emitMetric, resp1.Config.EmitMetric)




×







157



        m.Equal(historyArchivalStatus, resp1.Config.HistoryArchivalStatus)




×







158



        m.Equal(historyArchivalURI, resp1.Config.HistoryArchivalURI)




×







159



        m.Equal(visibilityArchivalStatus, resp1.Config.VisibilityArchivalStatus)




×







160



        m.Equal(visibilityArchivalURI, resp1.Config.VisibilityArchivalURI)




×







161



        m.Equal(badBinaries, resp1.Config.BadBinaries)




×







162



        m.Equal(cluster.TestCurrentClusterName, resp1.ReplicationConfig.ActiveClusterName)




×







163



        m.Equal(1, len(resp1.ReplicationConfig.Clusters))




×







164



        m.Equal(isGlobalDomain, resp1.IsGlobalDomain)




×







165



        m.Equal(configVersion, resp1.ConfigVersion)




×







166



        m.Equal(failoverVersion, resp1.FailoverVersion)




×







167



        m.Equal(common.InitialPreviousFailoverVersion, resp1.PreviousFailoverVersion)




×







168



        m.True(resp1.ReplicationConfig.Clusters[0].ClusterName == cluster.TestCurrentClusterName)




×







169



        m.Equal(p.InitialFailoverNotificationVersion, resp1.FailoverNotificationVersion)




×







170



        m.Nil(resp1.FailoverEndTime)




×







171



        m.Equal(lastUpdateTime, resp1.LastUpdatedTime)




×







172






×








173



        var isolationgroups types.IsolationGroupConfiguration




×







174



        resp2, err2 := m.CreateDomain(




×







175



                ctx,




×







176



                &p.DomainInfo{




×







177



                        ID:          uuid.New(),




×







178



                        Name:        name,




×







179



                        Status:      status,




×







180



                        Description: "fail",




×







181



                        OwnerEmail:  "fail",




×







182



                        Data:        map[string]string{},




×







183



                },




×







184



                &p.DomainConfig{




×







185



                        Retention:                100,




×







186



                        EmitMetric:               false,




×







187



                        HistoryArchivalStatus:    types.ArchivalStatusDisabled,




×







188



                        HistoryArchivalURI:       "",




×







189



                        VisibilityArchivalStatus: types.ArchivalStatusDisabled,




×







190



                        VisibilityArchivalURI:    "",




×








191



                        IsolationGroups:          isolationgroups,




×







192



                },




×







193



                &p.DomainReplicationConfig{},




×







194



                isGlobalDomain,




×







195



                configVersion,




×







196



                failoverVersion,




×







197



                0,




×







198



        )




×







199



        m.Error(err2)




×







200



        m.IsType(&types.DomainAlreadyExistsError{}, err2)




×







201



        m.Nil(resp2)




×







202



}




×







203












204



// TestGetDomain test










205



func (m *MetadataPersistenceSuiteV2) TestGetDomain() {




×







206



        ctx, cancel := context.WithTimeout(context.Background(), testContextTimeout)




×







207



        defer cancel()




×







208






×







209



        id := uuid.New()




×







210



        name := "get-domain-test-name"




×







211



        status := p.DomainStatusRegistered




×







212



        description := "get-domain-test-description"




×







213



        owner := "get-domain-test-owner"




×







214



        data := map[string]string{"k1": "v1"}




×







215



        retention := int32(10)




×







216



        emitMetric := true




×







217



        historyArchivalStatus := types.ArchivalStatusEnabled




×







218



        historyArchivalURI := "test://history/uri"




×







219



        visibilityArchivalStatus := types.ArchivalStatusEnabled




×







220



        visibilityArchivalURI := "test://visibility/uri"




×







221






×







222



        clusterActive := "some random active cluster name"




×







223



        clusterStandby := "some random standby cluster name"




×







224



        configVersion := int64(11)




×







225



        failoverVersion := int64(59)




×







226



        isGlobalDomain := true




×







227



        clusters := []*p.ClusterReplicationConfig{




×







228



                {




×







229



                        ClusterName: clusterActive,




×







230



                },




×







231



                {




×







232



                        ClusterName: clusterStandby,




×







233



                },




×







234



        }




×







235






×







236



        resp0, err0 := m.GetDomain(ctx, "", "does-not-exist")




×







237



        m.Nil(resp0)




×







238



        m.Error(err0)




×







239



        m.IsType(&types.EntityNotExistsError{}, err0)




×







240



        testBinaries := types.BadBinaries{




×







241



                Binaries: map[string]*types.BadBinaryInfo{




×







242



                        "abc": {




×







243



                                Reason:          "test-reason",




×







244



                                Operator:        "test-operator",




×







245



                                CreatedTimeNano: common.Int64Ptr(123),




×







246



                        },




×







247



                },




×







248



        }




×







249






×







250



        resp1, err1 := m.CreateDomain(




×







251



                ctx,




×







252



                &p.DomainInfo{




×







253



                        ID:          id,




×







254



                        Name:        name,




×







255



                        Status:      status,




×







256



                        Description: description,




×







257



                        OwnerEmail:  owner,




×







258



                        Data:        data,




×







259



                },




×







260



                &p.DomainConfig{




×







261



                        Retention:                retention,




×







262



                        EmitMetric:               emitMetric,




×







263



                        HistoryArchivalStatus:    historyArchivalStatus,




×







264



                        HistoryArchivalURI:       historyArchivalURI,




×







265



                        VisibilityArchivalStatus: visibilityArchivalStatus,




×







266



                        VisibilityArchivalURI:    visibilityArchivalURI,




×







267



                        BadBinaries:              testBinaries,




×







268



                },




×







269



                &p.DomainReplicationConfig{




×







270



                        ActiveClusterName: clusterActive,




×







271



                        Clusters:          clusters,




×







272



                },




×







273



                isGlobalDomain,




×







274



                configVersion,




×







275



                failoverVersion,




×







276



                0,




×







277



        )




×







278



        m.NoError(err1)




×







279



        m.NotNil(resp1)




×







280



        m.Equal(id, resp1.ID)




×







281






×







282



        resp2, err2 := m.GetDomain(ctx, id, "")




×







283



        m.NoError(err2)




×







284



        m.NotNil(resp2)




×







285



        m.Equal(id, resp2.Info.ID)




×







286



        m.Equal(name, resp2.Info.Name)




×







287



        m.Equal(status, resp2.Info.Status)




×







288



        m.Equal(description, resp2.Info.Description)




×







289



        m.Equal(owner, resp2.Info.OwnerEmail)




×







290



        m.Equal(data, resp2.Info.Data)




×







291



        m.Equal(retention, resp2.Config.Retention)




×







292



        m.Equal(emitMetric, resp2.Config.EmitMetric)




×







293



        m.Equal(historyArchivalStatus, resp2.Config.HistoryArchivalStatus)




×







294



        m.Equal(historyArchivalURI, resp2.Config.HistoryArchivalURI)




×







295



        m.Equal(visibilityArchivalStatus, resp2.Config.VisibilityArchivalStatus)




×







296



        m.Equal(visibilityArchivalURI, resp2.Config.VisibilityArchivalURI)




×







297



        m.Equal(testBinaries, resp2.Config.BadBinaries)




×







298



        m.Equal(clusterActive, resp2.ReplicationConfig.ActiveClusterName)




×







299



        m.Equal(len(clusters), len(resp2.ReplicationConfig.Clusters))




×







300



        for index := range clusters {




×







301



                m.Equal(clusters[index], resp2.ReplicationConfig.Clusters[index])




×







302



        }




×







303



        m.Equal(isGlobalDomain, resp2.IsGlobalDomain)




×







304



        m.Equal(configVersion, resp2.ConfigVersion)




×







305



        m.Equal(failoverVersion, resp2.FailoverVersion)




×







306



        m.Equal(common.InitialPreviousFailoverVersion, resp2.PreviousFailoverVersion)




×







307



        m.Equal(p.InitialFailoverNotificationVersion, resp2.FailoverNotificationVersion)




×







308



        m.Nil(resp2.FailoverEndTime)




×







309



        m.NotEqual(0, resp2.LastUpdatedTime)




×







310






×







311



        resp3, err3 := m.GetDomain(ctx, "", name)




×







312



        m.NoError(err3)




×







313



        m.NotNil(resp3)




×







314



        m.Equal(id, resp3.Info.ID)




×







315



        m.Equal(name, resp3.Info.Name)




×







316



        m.Equal(status, resp3.Info.Status)




×







317



        m.Equal(description, resp3.Info.Description)




×







318



        m.Equal(owner, resp3.Info.OwnerEmail)




×







319



        m.Equal(data, resp3.Info.Data)




×







320



        m.Equal(retention, resp3.Config.Retention)




×







321



        m.Equal(emitMetric, resp3.Config.EmitMetric)




×







322



        m.Equal(historyArchivalStatus, resp3.Config.HistoryArchivalStatus)




×







323



        m.Equal(historyArchivalURI, resp3.Config.HistoryArchivalURI)




×







324



        m.Equal(visibilityArchivalStatus, resp3.Config.VisibilityArchivalStatus)




×







325



        m.Equal(visibilityArchivalURI, resp3.Config.VisibilityArchivalURI)




×







326



        m.Equal(clusterActive, resp3.ReplicationConfig.ActiveClusterName)




×







327



        m.Equal(len(clusters), len(resp3.ReplicationConfig.Clusters))




×







328



        for index := range clusters {




×







329



                m.Equal(clusters[index], resp3.ReplicationConfig.Clusters[index])




×







330



        }




×







331



        m.Equal(isGlobalDomain, resp3.IsGlobalDomain)




×







332



        m.Equal(configVersion, resp3.ConfigVersion)




×







333



        m.Equal(failoverVersion, resp3.FailoverVersion)




×







334



        m.Equal(common.InitialPreviousFailoverVersion, resp2.PreviousFailoverVersion)




×







335



        m.Equal(p.InitialFailoverNotificationVersion, resp3.FailoverNotificationVersion)




×







336



        m.NotEqual(0, resp3.LastUpdatedTime)




×







337






×







338



        resp4, err4 := m.GetDomain(ctx, id, name)




×







339



        m.Error(err4)




×







340



        m.IsType(&types.BadRequestError{}, err4)




×







341



        m.Nil(resp4)




×







342






×







343



        resp5, err5 := m.GetDomain(ctx, "", "")




×







344



        m.Nil(resp5)




×







345



        m.IsType(&types.BadRequestError{}, err5)




×







346






×







347



        _, err6 := m.CreateDomain(ctx,




×







348



                &p.DomainInfo{




×







349



                        ID:          uuid.New(),




×







350



                        Name:        name,




×







351



                        Status:      status,




×







352



                        Description: description,




×







353



                        OwnerEmail:  owner,




×







354



                        Data:        data,




×







355



                },




×







356



                &p.DomainConfig{




×







357



                        Retention:                retention,




×







358



                        EmitMetric:               emitMetric,




×







359



                        HistoryArchivalStatus:    historyArchivalStatus,




×







360



                        HistoryArchivalURI:       historyArchivalURI,




×







361



                        VisibilityArchivalStatus: visibilityArchivalStatus,




×







362



                        VisibilityArchivalURI:    visibilityArchivalURI,




×







363



                },




×







364



                &p.DomainReplicationConfig{




×







365



                        ActiveClusterName: clusterActive,




×







366



                        Clusters:          clusters,




×







367



                },




×







368



                isGlobalDomain,




×







369



                configVersion,




×







370



                failoverVersion,




×







371



                0,




×







372



        )




×







373



        m.Error(err6)




×







374



}










375












376



// TestConcurrentCreateDomain test










377



func (m *MetadataPersistenceSuiteV2) TestConcurrentCreateDomain() {




×







378



        ctx, cancel := context.WithTimeout(context.Background(), testContextTimeout)




×







379



        defer cancel()




×







380






×







381



        concurrency := 16




×







382



        numDomains := 5




×







383



        domainIDs := make([]string, numDomains)




×







384



        names := make([]string, numDomains)




×







385



        registered := make([]bool, numDomains)




×







386



        for idx := range domainIDs {




×







387



                domainIDs[idx] = uuid.New()




×







388



                names[idx] = "concurrent-create-domain-test-name-" + strconv.Itoa(idx)




×







389



        }




×







390












391



        status := p.DomainStatusRegistered




×







392



        description := "concurrent-create-domain-test-description"




×







393



        owner := "create-domain-test-owner"




×







394



        retention := int32(10)




×







395



        emitMetric := true




×







396



        historyArchivalStatus := types.ArchivalStatusEnabled




×







397



        historyArchivalURI := "test://history/uri"




×







398



        visibilityArchivalStatus := types.ArchivalStatusEnabled




×







399



        visibilityArchivalURI := "test://visibility/uri"




×







400






×







401



        clusterActive := "some random active cluster name"




×







402



        clusterStandby := "some random standby cluster name"




×







403



        configVersion := int64(10)




×







404



        failoverVersion := int64(59)




×







405



        isGlobalDomain := true




×







406



        clusters := []*p.ClusterReplicationConfig{




×







407



                {




×







408



                        ClusterName: clusterActive,




×







409



                },




×







410



                {




×







411



                        ClusterName: clusterStandby,




×







412



                },




×







413



        }




×







414






×







415



        testBinaries := types.BadBinaries{




×







416



                Binaries: map[string]*types.BadBinaryInfo{




×







417



                        "abc": {




×







418



                                Reason:          "test-reason",




×







419



                                Operator:        "test-operator",




×







420



                                CreatedTimeNano: common.Int64Ptr(123),




×







421



                        },




×







422



                },




×







423



        }




×







424



        successCount := 0




×







425



        var mutex sync.Mutex




×







426



        var wg sync.WaitGroup




×







427



        for i := 1; i <= concurrency; i++ {




×







428



                wg.Add(1)




×







429



                go func(idx int) {




×







430



                        data := map[string]string{"k0": fmt.Sprintf("v-%v", idx)}




×







431



                        _, err1 := m.CreateDomain(ctx,




×







432



                                &p.DomainInfo{




×







433



                                        ID:          domainIDs[idx%numDomains],




×







434



                                        Name:        names[idx%numDomains],




×







435



                                        Status:      status,




×







436



                                        Description: description,




×







437



                                        OwnerEmail:  owner,




×







438



                                        Data:        data,




×







439



                                },




×







440



                                &p.DomainConfig{




×







441



                                        Retention:                retention,




×







442



                                        EmitMetric:               emitMetric,




×







443



                                        HistoryArchivalStatus:    historyArchivalStatus,




×







444



                                        HistoryArchivalURI:       historyArchivalURI,




×







445



                                        VisibilityArchivalStatus: visibilityArchivalStatus,




×







446



                                        VisibilityArchivalURI:    visibilityArchivalURI,




×







447



                                        BadBinaries:              testBinaries,




×







448



                                },




×







449



                                &p.DomainReplicationConfig{




×







450



                                        ActiveClusterName: clusterActive,




×







451



                                        Clusters:          clusters,




×







452



                                },




×







453



                                isGlobalDomain,




×







454



                                configVersion,




×







455



                                failoverVersion,




×







456



                                0,




×







457



                        )




×







458



                        mutex.Lock()




×







459



                        defer mutex.Unlock()




×







460



                        if err1 == nil {




×







461



                                successCount++




×







462



                                registered[idx%numDomains] = true




×







463



                        }




×







464



                        if _, ok := err1.(*types.DomainAlreadyExistsError); ok {




×







465



                                registered[idx%numDomains] = true




×







466



                        }




×







467



                        wg.Done()




×







468



                }(i)










469



        }










470



        wg.Wait()




×







471



        m.GreaterOrEqual(successCount, 1)




×







472






×







473



        for i := 0; i != numDomains; i++ {




×







474



                if !registered[i] {




×







475



                        continue




×







476



                }










477












478



                resp, err3 := m.GetDomain(ctx, "", names[i])




×







479



                m.NoError(err3)




×







480



                m.NotNil(resp)




×







481



                m.Equal(domainIDs[i], resp.Info.ID)




×







482



                m.Equal(names[i], resp.Info.Name)




×







483



                m.Equal(status, resp.Info.Status)




×







484



                m.Equal(description, resp.Info.Description)




×







485



                m.Equal(owner, resp.Info.OwnerEmail)




×







486



                m.Equal(retention, resp.Config.Retention)




×







487



                m.Equal(emitMetric, resp.Config.EmitMetric)




×







488



                m.Equal(historyArchivalStatus, resp.Config.HistoryArchivalStatus)




×







489



                m.Equal(historyArchivalURI, resp.Config.HistoryArchivalURI)




×







490



                m.Equal(visibilityArchivalStatus, resp.Config.VisibilityArchivalStatus)




×







491



                m.Equal(visibilityArchivalURI, resp.Config.VisibilityArchivalURI)




×







492



                m.Equal(testBinaries, resp.Config.BadBinaries)




×







493



                m.Equal(clusterActive, resp.ReplicationConfig.ActiveClusterName)




×







494



                m.Equal(len(clusters), len(resp.ReplicationConfig.Clusters))




×







495



                for index := range clusters {




×







496



                        m.Equal(clusters[index], resp.ReplicationConfig.Clusters[index])




×







497



                }




×







498



                m.Equal(isGlobalDomain, resp.IsGlobalDomain)




×







499



                m.Equal(configVersion, resp.ConfigVersion)




×







500



                m.Equal(failoverVersion, resp.FailoverVersion)




×







501



                m.Equal(common.InitialPreviousFailoverVersion, resp.PreviousFailoverVersion)




×







502






×







503



                //check domain data




×







504



                ss := strings.Split(resp.Info.Data["k0"], "-")




×







505



                m.Equal(2, len(ss))




×







506



                vi, err := strconv.Atoi(ss[1])




×







507



                m.NoError(err)




×







508



                m.Equal(true, vi > 0 && vi <= concurrency)




×







509



        }










510



}










511












512



// TestConcurrentUpdateDomain test










513



func (m *MetadataPersistenceSuiteV2) TestConcurrentUpdateDomain() {




×







514



        ctx, cancel := context.WithTimeout(context.Background(), testContextTimeout)




×







515



        defer cancel()




×







516






×








517



        isolationGroups := types.IsolationGroupConfiguration{




×








518



                "zone-1": types.IsolationGroupPartition{




×








519



                        Name:  "zone-1",




×








520



                        State: types.IsolationGroupStateDrained,




×








521



                },




×








522



                "zone-2": types.IsolationGroupPartition{




×








523



                        Name:  "zone-2",




×








524



                        State: types.IsolationGroupStateHealthy,




×








525



                },




×








526



        }




×








527






×







528



        id := uuid.New()




×







529



        name := "concurrent-update-domain-test-name"




×







530



        status := p.DomainStatusRegistered




×







531



        description := "update-domain-test-description"




×







532



        owner := "update-domain-test-owner"




×







533



        data := map[string]string{"k1": "v1"}




×







534



        retention := int32(10)




×







535



        emitMetric := true




×







536



        historyArchivalStatus := types.ArchivalStatusEnabled




×







537



        historyArchivalURI := "test://history/uri"




×







538



        visibilityArchivalStatus := types.ArchivalStatusEnabled




×







539



        visibilityArchivalURI := "test://visibility/uri"




×







540



        badBinaries := types.BadBinaries{map[string]*types.BadBinaryInfo{}}




×







541






×







542



        clusterActive := "some random active cluster name"




×







543



        clusterStandby := "some random standby cluster name"




×







544



        configVersion := int64(10)




×







545



        failoverVersion := int64(59)




×







546



        isGlobalDomain := true




×







547



        clusters := []*p.ClusterReplicationConfig{




×







548



                {




×







549



                        ClusterName: clusterActive,




×







550



                },




×







551



                {




×







552



                        ClusterName: clusterStandby,




×







553



                },




×







554



        }




×







555






×







556



        resp1, err1 := m.CreateDomain(ctx,




×







557



                &p.DomainInfo{




×







558



                        ID:          id,




×







559



                        Name:        name,




×







560



                        Status:      status,




×







561



                        Description: description,




×







562



                        OwnerEmail:  owner,




×







563



                        Data:        data,




×







564



                },




×







565



                &p.DomainConfig{




×







566



                        Retention:                retention,




×







567



                        EmitMetric:               emitMetric,




×







568



                        HistoryArchivalStatus:    historyArchivalStatus,




×







569



                        HistoryArchivalURI:       historyArchivalURI,




×







570



                        VisibilityArchivalStatus: visibilityArchivalStatus,




×







571



                        VisibilityArchivalURI:    visibilityArchivalURI,




×







572



                        BadBinaries:              badBinaries,




×








573



                        IsolationGroups:          isolationGroups,




×







574



                },




×







575



                &p.DomainReplicationConfig{




×







576



                        ActiveClusterName: clusterActive,




×







577



                        Clusters:          clusters,




×







578



                },




×







579



                isGlobalDomain,




×







580



                configVersion,




×







581



                failoverVersion,




×







582



                0,




×







583



        )




×







584



        m.NoError(err1)




×







585



        m.Equal(id, resp1.ID)




×







586






×







587



        resp2, err2 := m.GetDomain(ctx, id, "")




×







588



        m.NoError(err2)




×







589



        m.Equal(badBinaries, resp2.Config.BadBinaries)




×







590



        metadata, err := m.DomainManager.GetMetadata(ctx)




×







591



        m.NoError(err)




×







592



        notificationVersion := metadata.NotificationVersion




×







593






×







594



        testBinaries := types.BadBinaries{




×







595



                Binaries: map[string]*types.BadBinaryInfo{




×







596



                        "abc": {




×







597



                                Reason:          "test-reason",




×







598



                                Operator:        "test-operator",




×







599



                                CreatedTimeNano: common.Int64Ptr(123),




×







600



                        },




×







601



                },




×







602



        }




×







603



        concurrency := 16




×







604



        successCount := int32(0)




×







605



        var wg sync.WaitGroup




×







606



        for i := 1; i <= concurrency; i++ {




×







607



                newValue := fmt.Sprintf("v-%v", i)




×







608



                wg.Add(1)




×







609



                go func(updatedData map[string]string) {




×







610



                        err3 := m.UpdateDomain(




×







611



                                ctx,




×







612



                                &p.DomainInfo{




×







613



                                        ID:          resp2.Info.ID,




×







614



                                        Name:        resp2.Info.Name,




×







615



                                        Status:      resp2.Info.Status,




×







616



                                        Description: resp2.Info.Description,




×







617



                                        OwnerEmail:  resp2.Info.OwnerEmail,




×







618



                                        Data:        updatedData,




×







619



                                },




×







620



                                &p.DomainConfig{




×







621



                                        Retention:                resp2.Config.Retention,




×







622



                                        EmitMetric:               resp2.Config.EmitMetric,




×







623



                                        HistoryArchivalStatus:    resp2.Config.HistoryArchivalStatus,




×







624



                                        HistoryArchivalURI:       resp2.Config.HistoryArchivalURI,




×







625



                                        VisibilityArchivalStatus: resp2.Config.VisibilityArchivalStatus,




×







626



                                        VisibilityArchivalURI:    resp2.Config.VisibilityArchivalURI,




×







627



                                        BadBinaries:              testBinaries,




×








628



                                        IsolationGroups:          isolationGroups,




×







629



                                },




×







630



                                &p.DomainReplicationConfig{




×







631



                                        ActiveClusterName: resp2.ReplicationConfig.ActiveClusterName,




×







632



                                        Clusters:          resp2.ReplicationConfig.Clusters,




×







633



                                },




×







634



                                resp2.ConfigVersion,




×







635



                                resp2.FailoverVersion,




×







636



                                resp2.FailoverNotificationVersion,




×







637



                                resp2.PreviousFailoverVersion,




×







638



                                nil,




×







639



                                notificationVersion,




×







640



                                0,




×







641



                        )




×







642



                        if err3 == nil {




×







643



                                atomic.AddInt32(&successCount, 1)




×







644



                        }




×







645



                        wg.Done()




×







646



                }(map[string]string{"k0": newValue})










647



        }










648



        wg.Wait()




×







649



        m.Greater(successCount, int32(0))




×







650



        allDomains, err := m.ListDomains(ctx, 100, nil)




×







651



        m.NoError(err)




×







652



        domainNameMap := make(map[string]bool)




×







653



        for _, domain := range allDomains.Domains {




×







654



                _, ok := domainNameMap[domain.Info.Name]




×







655



                m.False(ok)




×







656



                domainNameMap[domain.Info.Name] = true




×







657



        }




×







658












659



        resp3, err3 := m.GetDomain(ctx, "", name)




×







660



        m.NoError(err3)




×







661



        m.NotNil(resp3)




×







662



        m.Equal(id, resp3.Info.ID)




×







663



        m.Equal(name, resp3.Info.Name)




×







664



        m.Equal(status, resp3.Info.Status)




×







665



        m.Equal(isGlobalDomain, resp3.IsGlobalDomain)




×







666



        m.Equal(description, resp3.Info.Description)




×







667



        m.Equal(owner, resp3.Info.OwnerEmail)




×







668






×







669



        m.Equal(retention, resp3.Config.Retention)




×







670



        m.Equal(emitMetric, resp3.Config.EmitMetric)




×







671



        m.Equal(historyArchivalStatus, resp3.Config.HistoryArchivalStatus)




×







672



        m.Equal(historyArchivalURI, resp3.Config.HistoryArchivalURI)




×







673



        m.Equal(visibilityArchivalStatus, resp3.Config.VisibilityArchivalStatus)




×







674



        m.Equal(visibilityArchivalURI, resp3.Config.VisibilityArchivalURI)




×







675



        m.Equal(testBinaries, resp3.Config.BadBinaries)




×







676



        m.Equal(clusterActive, resp3.ReplicationConfig.ActiveClusterName)




×







677



        m.Equal(len(clusters), len(resp3.ReplicationConfig.Clusters))




×







678



        for index := range clusters {




×







679



                m.Equal(clusters[index], resp3.ReplicationConfig.Clusters[index])




×







680



        }




×







681



        m.Equal(isGlobalDomain, resp3.IsGlobalDomain)




×







682



        m.Equal(configVersion, resp3.ConfigVersion)




×







683



        m.Equal(failoverVersion, resp3.FailoverVersion)




×







684



        m.Equal(common.InitialPreviousFailoverVersion, resp3.PreviousFailoverVersion)




×







685






×







686



        //check domain data




×







687



        ss := strings.Split(resp3.Info.Data["k0"], "-")




×







688



        m.Equal(2, len(ss))




×







689



        vi, err := strconv.Atoi(ss[1])




×







690



        m.NoError(err)




×







691



        m.Equal(true, vi > 0 && vi <= concurrency)




×







692



}










693












694



// TestUpdateDomain test










695



func (m *MetadataPersistenceSuiteV2) TestUpdateDomain() {




×







696



        ctx, cancel := context.WithTimeout(context.Background(), testContextTimeout)




×







697



        defer cancel()




×







698






×








699



        isolationGroups1 := types.IsolationGroupConfiguration{}




×








700






×








701



        isolationGroups2 := types.IsolationGroupConfiguration{




×








702



                "zone-1": types.IsolationGroupPartition{




×








703



                        Name:  "zone-1",




×








704



                        State: types.IsolationGroupStateDrained,




×








705



                },




×








706



                "zone-2": types.IsolationGroupPartition{




×








707



                        Name:  "zone-2",




×








708



                        State: types.IsolationGroupStateHealthy,




×








709



                },




×








710



        }




×








711






×







712



        id := uuid.New()




×







713



        name := "update-domain-test-name"




×







714



        status := p.DomainStatusRegistered




×







715



        description := "update-domain-test-description"




×







716



        owner := "update-domain-test-owner"




×







717



        data := map[string]string{"k1": "v1"}




×







718



        retention := int32(10)




×







719



        emitMetric := true




×







720



        historyArchivalStatus := types.ArchivalStatusEnabled




×







721



        historyArchivalURI := "test://history/uri"




×







722



        visibilityArchivalStatus := types.ArchivalStatusEnabled




×







723



        visibilityArchivalURI := "test://visibility/uri"




×







724






×







725



        clusterActive := "some random active cluster name"




×







726



        clusterStandby := "some random standby cluster name"




×







727



        configVersion := int64(10)




×







728



        failoverVersion := int64(59)




×







729



        failoverEndTime := time.Now().UnixNano()




×







730



        isGlobalDomain := true




×







731



        lastUpdateTime := int64(100)




×







732



        clusters := []*p.ClusterReplicationConfig{




×







733



                {




×







734



                        ClusterName: clusterActive,




×







735



                },




×







736



                {




×







737



                        ClusterName: clusterStandby,




×







738



                },




×







739



        }




×







740






×







741



        resp1, err1 := m.CreateDomain(




×







742



                ctx,




×







743



                &p.DomainInfo{




×







744



                        ID:          id,




×







745



                        Name:        name,




×







746



                        Status:      status,




×







747



                        Description: description,




×







748



                        OwnerEmail:  owner,




×







749



                        Data:        data,




×







750



                },




×







751



                &p.DomainConfig{




×







752



                        Retention:                retention,




×







753



                        EmitMetric:               emitMetric,




×







754



                        HistoryArchivalStatus:    historyArchivalStatus,




×







755



                        HistoryArchivalURI:       historyArchivalURI,




×







756



                        VisibilityArchivalStatus: visibilityArchivalStatus,




×







757



                        VisibilityArchivalURI:    visibilityArchivalURI,




×








758



                        IsolationGroups:          isolationGroups1,




×







759



                },




×







760



                &p.DomainReplicationConfig{




×







761



                        ActiveClusterName: clusterActive,




×







762



                        Clusters:          clusters,




×







763



                },




×







764



                isGlobalDomain,




×







765



                configVersion,




×







766



                failoverVersion,




×







767



                lastUpdateTime,




×







768



        )




×







769



        m.NoError(err1)




×







770



        m.Equal(id, resp1.ID)




×







771






×







772



        resp2, err2 := m.GetDomain(ctx, id, "")




×







773



        m.NoError(err2)




×







774



        m.Nil(resp2.FailoverEndTime)




×







775



        metadata, err := m.DomainManager.GetMetadata(ctx)




×







776



        m.NoError(err)




×







777



        notificationVersion := metadata.NotificationVersion




×







778






×







779



        updatedStatus := p.DomainStatusDeprecated




×







780



        updatedDescription := "description-updated"




×







781



        updatedOwner := "owner-updated"




×







782



        //This will overriding the previous key-value pair




×







783



        updatedData := map[string]string{"k1": "v2"}




×







784



        updatedRetention := int32(20)




×







785



        updatedEmitMetric := false




×







786



        updatedHistoryArchivalStatus := types.ArchivalStatusDisabled




×







787



        updatedHistoryArchivalURI := ""




×







788



        updatedVisibilityArchivalStatus := types.ArchivalStatusDisabled




×







789



        updatedVisibilityArchivalURI := ""




×







790






×







791



        updateClusterActive := "other random active cluster name"




×







792



        updateClusterStandby := "other random standby cluster name"




×







793



        lastUpdateTime++




×







794



        updateConfigVersion := int64(12)




×







795



        updateFailoverVersion := int64(28)




×







796



        updatePreviousFailoverVersion := int64(20)




×







797



        updateFailoverNotificationVersion := int64(14)




×







798



        updateClusters := []*p.ClusterReplicationConfig{




×







799



                {




×







800



                        ClusterName: updateClusterActive,




×







801



                },




×







802



                {




×







803



                        ClusterName: updateClusterStandby,




×







804



                },




×







805



        }




×







806



        testBinaries := types.BadBinaries{




×







807



                Binaries: map[string]*types.BadBinaryInfo{




×







808



                        "abc": {




×







809



                                Reason:          "test-reason",




×







810



                                Operator:        "test-operator",




×







811



                                CreatedTimeNano: common.Int64Ptr(123),




×







812



                        },




×







813



                },




×







814



        }




×







815






×







816



        err3 := m.UpdateDomain(




×







817



                ctx,




×







818



                &p.DomainInfo{




×







819



                        ID:          resp2.Info.ID,




×







820



                        Name:        resp2.Info.Name,




×







821



                        Status:      updatedStatus,




×







822



                        Description: updatedDescription,




×







823



                        OwnerEmail:  updatedOwner,




×







824



                        Data:        updatedData,




×







825



                },




×







826



                &p.DomainConfig{




×







827



                        Retention:                updatedRetention,




×







828



                        EmitMetric:               updatedEmitMetric,




×







829



                        HistoryArchivalStatus:    updatedHistoryArchivalStatus,




×







830



                        HistoryArchivalURI:       updatedHistoryArchivalURI,




×







831



                        VisibilityArchivalStatus: updatedVisibilityArchivalStatus,




×







832



                        VisibilityArchivalURI:    updatedVisibilityArchivalURI,




×







833



                        BadBinaries:              testBinaries,




×








834



                        IsolationGroups:          isolationGroups2,




×







835



                },




×







836



                &p.DomainReplicationConfig{




×







837



                        ActiveClusterName: updateClusterActive,




×







838



                        Clusters:          updateClusters,




×







839



                },




×







840



                updateConfigVersion,




×







841



                updateFailoverVersion,




×







842



                updateFailoverNotificationVersion,




×







843



                updatePreviousFailoverVersion,




×







844



                &failoverEndTime,




×







845



                notificationVersion,




×







846



                lastUpdateTime,




×







847



        )




×







848



        m.NoError(err3)




×







849






×







850



        resp4, err4 := m.GetDomain(ctx, "", name)




×







851



        m.NoError(err4)




×







852



        m.NotNil(resp4)




×







853



        m.Equal(id, resp4.Info.ID)




×







854



        m.Equal(name, resp4.Info.Name)




×







855



        m.Equal(isGlobalDomain, resp4.IsGlobalDomain)




×







856



        m.Equal(updatedStatus, resp4.Info.Status)




×







857



        m.Equal(updatedDescription, resp4.Info.Description)




×







858



        m.Equal(updatedOwner, resp4.Info.OwnerEmail)




×







859



        m.Equal(updatedData, resp4.Info.Data)




×







860



        m.Equal(updatedRetention, resp4.Config.Retention)




×







861



        m.Equal(updatedEmitMetric, resp4.Config.EmitMetric)




×







862



        m.Equal(updatedHistoryArchivalStatus, resp4.Config.HistoryArchivalStatus)




×







863



        m.Equal(updatedHistoryArchivalURI, resp4.Config.HistoryArchivalURI)




×







864



        m.Equal(updatedVisibilityArchivalStatus, resp4.Config.VisibilityArchivalStatus)




×







865



        m.Equal(updatedVisibilityArchivalURI, resp4.Config.VisibilityArchivalURI)




×







866



        m.Equal(testBinaries, resp4.Config.BadBinaries)




×







867



        m.Equal(updateClusterActive, resp4.ReplicationConfig.ActiveClusterName)




×







868



        m.Equal(len(updateClusters), len(resp4.ReplicationConfig.Clusters))




×







869



        for index := range clusters {




×







870



                m.Equal(updateClusters[index], resp4.ReplicationConfig.Clusters[index])




×







871



        }




×







872



        m.Equal(updateConfigVersion, resp4.ConfigVersion)




×







873



        m.Equal(updateFailoverVersion, resp4.FailoverVersion)




×







874



        m.Equal(updatePreviousFailoverVersion, resp4.PreviousFailoverVersion)




×







875



        m.Equal(updateFailoverNotificationVersion, resp4.FailoverNotificationVersion)




×







876



        m.Equal(notificationVersion, resp4.NotificationVersion)




×







877



        m.Equal(&failoverEndTime, resp4.FailoverEndTime)




×







878



        m.Equal(lastUpdateTime, resp4.LastUpdatedTime)




×








879



        m.Equal(isolationGroups2, resp4.Config.IsolationGroups)




×







880






×







881



        resp5, err5 := m.GetDomain(ctx, id, "")




×







882



        m.NoError(err5)




×







883



        m.NotNil(resp5)




×







884



        m.Equal(id, resp5.Info.ID)




×







885



        m.Equal(name, resp5.Info.Name)




×







886



        m.Equal(isGlobalDomain, resp5.IsGlobalDomain)




×







887



        m.Equal(updatedStatus, resp5.Info.Status)




×







888



        m.Equal(updatedDescription, resp5.Info.Description)




×







889



        m.Equal(updatedOwner, resp5.Info.OwnerEmail)




×







890



        m.Equal(updatedData, resp5.Info.Data)




×







891



        m.Equal(updatedRetention, resp5.Config.Retention)




×







892



        m.Equal(updatedEmitMetric, resp5.Config.EmitMetric)




×







893



        m.Equal(updatedHistoryArchivalStatus, resp5.Config.HistoryArchivalStatus)




×







894



        m.Equal(updatedHistoryArchivalURI, resp5.Config.HistoryArchivalURI)




×







895



        m.Equal(updatedVisibilityArchivalStatus, resp5.Config.VisibilityArchivalStatus)




×







896



        m.Equal(updatedVisibilityArchivalURI, resp5.Config.VisibilityArchivalURI)




×







897



        m.Equal(updateClusterActive, resp5.ReplicationConfig.ActiveClusterName)




×







898



        m.Equal(len(updateClusters), len(resp5.ReplicationConfig.Clusters))




×







899



        for index := range clusters {




×







900



                m.Equal(updateClusters[index], resp5.ReplicationConfig.Clusters[index])




×







901



        }




×







902



        m.Equal(updateConfigVersion, resp5.ConfigVersion)




×







903



        m.Equal(updateFailoverVersion, resp5.FailoverVersion)




×







904



        m.Equal(updatePreviousFailoverVersion, resp5.PreviousFailoverVersion)




×







905



        m.Equal(updateFailoverNotificationVersion, resp5.FailoverNotificationVersion)




×







906



        m.Equal(notificationVersion, resp5.NotificationVersion)




×







907



        m.Equal(&failoverEndTime, resp5.FailoverEndTime)




×







908



        m.Equal(lastUpdateTime, resp5.LastUpdatedTime)




×







909






×







910



        notificationVersion++




×







911



        lastUpdateTime++




×







912



        err6 := m.UpdateDomain(




×







913



                ctx,




×







914



                &p.DomainInfo{




×







915



                        ID:          resp2.Info.ID,




×







916



                        Name:        resp2.Info.Name,




×







917



                        Status:      updatedStatus,




×







918



                        Description: updatedDescription,




×







919



                        OwnerEmail:  updatedOwner,




×







920



                        Data:        updatedData,




×







921



                },




×







922



                &p.DomainConfig{




×







923



                        Retention:                updatedRetention,




×







924



                        EmitMetric:               updatedEmitMetric,




×







925



                        HistoryArchivalStatus:    updatedHistoryArchivalStatus,




×







926



                        HistoryArchivalURI:       updatedHistoryArchivalURI,




×







927



                        VisibilityArchivalStatus: updatedVisibilityArchivalStatus,




×







928



                        VisibilityArchivalURI:    updatedVisibilityArchivalURI,




×







929



                        BadBinaries:              testBinaries,




×








930



                        IsolationGroups:          isolationGroups1,




×







931



                },




×







932



                &p.DomainReplicationConfig{




×







933



                        ActiveClusterName: updateClusterActive,




×







934



                        Clusters:          updateClusters,




×







935



                },




×







936



                updateConfigVersion,




×







937



                updateFailoverVersion,




×







938



                updateFailoverNotificationVersion,




×







939



                updatePreviousFailoverVersion,




×







940



                nil,




×







941



                notificationVersion,




×







942



                lastUpdateTime,




×







943



        )




×







944



        m.NoError(err6)




×







945






×







946



        resp6, err6 := m.GetDomain(ctx, "", name)




×







947



        m.NoError(err6)




×







948



        m.NotNil(resp6)




×







949



        m.Equal(id, resp6.Info.ID)




×







950



        m.Equal(name, resp6.Info.Name)




×







951



        m.Equal(isGlobalDomain, resp6.IsGlobalDomain)




×







952



        m.Equal(updatedStatus, resp6.Info.Status)




×







953



        m.Equal(updatedDescription, resp6.Info.Description)




×







954



        m.Equal(updatedOwner, resp6.Info.OwnerEmail)




×







955



        m.Equal(updatedData, resp6.Info.Data)




×







956



        m.Equal(updatedRetention, resp6.Config.Retention)




×







957



        m.Equal(updatedEmitMetric, resp6.Config.EmitMetric)




×







958



        m.Equal(updatedHistoryArchivalStatus, resp6.Config.HistoryArchivalStatus)




×







959



        m.Equal(updatedHistoryArchivalURI, resp6.Config.HistoryArchivalURI)




×







960



        m.Equal(updatedVisibilityArchivalStatus, resp6.Config.VisibilityArchivalStatus)




×







961



        m.Equal(updatedVisibilityArchivalURI, resp6.Config.VisibilityArchivalURI)




×







962



        m.Equal(testBinaries, resp6.Config.BadBinaries)




×







963



        m.Equal(updateClusterActive, resp6.ReplicationConfig.ActiveClusterName)




×







964



        m.Equal(len(updateClusters), len(resp6.ReplicationConfig.Clusters))




×







965



        for index := range clusters {




×







966



                m.Equal(updateClusters[index], resp6.ReplicationConfig.Clusters[index])




×







967



        }




×







968



        m.Equal(updateConfigVersion, resp6.ConfigVersion)




×







969



        m.Equal(updateFailoverVersion, resp6.FailoverVersion)




×







970



        m.Equal(updatePreviousFailoverVersion, resp6.PreviousFailoverVersion)




×







971



        m.Equal(updateFailoverNotificationVersion, resp6.FailoverNotificationVersion)




×







972



        m.Equal(notificationVersion, resp6.NotificationVersion)




×







973



        m.Nil(resp6.FailoverEndTime)




×







974



        m.Equal(lastUpdateTime, resp6.LastUpdatedTime)




×








975



        m.Equal(isolationGroups1, resp6.Config.IsolationGroups)




×







976



}










977












978



// TestDeleteDomain test










979



func (m *MetadataPersistenceSuiteV2) TestDeleteDomain() {




×







980



        ctx, cancel := context.WithTimeout(context.Background(), testContextTimeout)




×







981



        defer cancel()




×







982






×







983



        id := uuid.New()




×







984



        name := "delete-domain-test-name"




×







985



        status := p.DomainStatusRegistered




×







986



        description := "delete-domain-test-description"




×







987



        owner := "delete-domain-test-owner"




×







988



        data := map[string]string{"k1": "v1"}




×







989



        retention := 10




×







990



        emitMetric := true




×







991



        historyArchivalStatus := types.ArchivalStatusEnabled




×







992



        historyArchivalURI := "test://history/uri"




×







993



        visibilityArchivalStatus := types.ArchivalStatusEnabled




×







994



        visibilityArchivalURI := "test://visibility/uri"




×








995



        var isolationGroups types.IsolationGroupConfiguration




×







996






×







997



        clusterActive := "some random active cluster name"




×







998



        clusterStandby := "some random standby cluster name"




×







999



        configVersion := int64(10)




×







1000



        failoverVersion := int64(59)




×







1001



        isGlobalDomain := true




×







1002



        clusters := []*p.ClusterReplicationConfig{




×







1003



                {




×







1004



                        ClusterName: clusterActive,




×







1005



                },




×







1006



                {




×







1007



                        ClusterName: clusterStandby,




×







1008



                },




×







1009



        }




×







1010






×







1011



        resp1, err1 := m.CreateDomain(




×







1012



                ctx,




×







1013



                &p.DomainInfo{




×







1014



                        ID:          id,




×







1015



                        Name:        name,




×







1016



                        Status:      status,




×







1017



                        Description: description,




×







1018



                        OwnerEmail:  owner,




×







1019



                        Data:        data,




×







1020



                },




×







1021



                &p.DomainConfig{




×







1022



                        Retention:                int32(retention),




×







1023



                        EmitMetric:               emitMetric,




×







1024



                        HistoryArchivalStatus:    historyArchivalStatus,




×







1025



                        HistoryArchivalURI:       historyArchivalURI,




×







1026



                        VisibilityArchivalStatus: visibilityArchivalStatus,




×







1027



                        VisibilityArchivalURI:    visibilityArchivalURI,




×








1028



                        IsolationGroups:          isolationGroups,




×







1029



                },




×







1030



                &p.DomainReplicationConfig{




×







1031



                        ActiveClusterName: clusterActive,




×







1032



                        Clusters:          clusters,




×







1033



                },




×







1034



                isGlobalDomain,




×







1035



                configVersion,




×







1036



                failoverVersion,




×







1037



                0,




×







1038



        )




×







1039



        m.NoError(err1)




×







1040



        m.Equal(id, resp1.ID)




×







1041






×







1042



        resp2, err2 := m.GetDomain(ctx, "", name)




×







1043



        m.NoError(err2)




×







1044



        m.NotNil(resp2)




×







1045






×







1046



        err3 := m.DeleteDomain(ctx, "", name)




×







1047



        m.NoError(err3)




×







1048






×







1049



        resp4, err4 := m.GetDomain(ctx, "", name)




×







1050



        m.Error(err4)




×







1051



        m.IsType(&types.EntityNotExistsError{}, err4)




×







1052



        m.Nil(resp4)




×







1053






×







1054



        resp5, err5 := m.GetDomain(ctx, id, "")




×







1055



        m.Error(err5)




×







1056



        m.IsType(&types.EntityNotExistsError{}, err5)




×







1057



        m.Nil(resp5)




×







1058






×







1059



        id = uuid.New()




×







1060



        resp6, err6 := m.CreateDomain(




×







1061



                ctx,




×







1062



                &p.DomainInfo{




×







1063



                        ID:          id,




×







1064



                        Name:        name,




×







1065



                        Status:      status,




×







1066



                        Description: description,




×







1067



                        OwnerEmail:  owner,




×







1068



                        Data:        data,




×







1069



                },




×







1070



                &p.DomainConfig{




×







1071



                        Retention:                int32(retention),




×







1072



                        EmitMetric:               emitMetric,




×







1073



                        HistoryArchivalStatus:    historyArchivalStatus,




×







1074



                        HistoryArchivalURI:       historyArchivalURI,




×







1075



                        VisibilityArchivalStatus: visibilityArchivalStatus,




×







1076



                        VisibilityArchivalURI:    visibilityArchivalURI,




×







1077



                },




×







1078



                &p.DomainReplicationConfig{




×







1079



                        ActiveClusterName: clusterActive,




×







1080



                        Clusters:          clusters,




×







1081



                },




×







1082



                isGlobalDomain,




×







1083



                configVersion,




×







1084



                failoverVersion,




×







1085



                0,




×







1086



        )




×







1087



        m.NoError(err6)




×







1088



        m.Equal(id, resp6.ID)




×







1089






×







1090



        err7 := m.DeleteDomain(ctx, id, "")




×







1091



        m.NoError(err7)




×







1092






×







1093



        resp8, err8 := m.GetDomain(ctx, "", name)




×







1094



        m.Error(err8)




×







1095



        m.IsType(&types.EntityNotExistsError{}, err8)




×







1096



        m.Nil(resp8)




×







1097






×







1098



        resp9, err9 := m.GetDomain(ctx, id, "")




×







1099



        m.Error(err9)




×







1100



        m.IsType(&types.EntityNotExistsError{}, err9)




×







1101



        m.Nil(resp9)




×







1102



}




×







1103












1104



// TestListDomains test










1105



func (m *MetadataPersistenceSuiteV2) TestListDomains() {




×







1106



        ctx, cancel := context.WithTimeout(context.Background(), testContextTimeout)




×







1107



        defer cancel()




×







1108






×







1109



        clusterActive1 := "some random active cluster name"




×







1110



        clusterStandby1 := "some random standby cluster name"




×







1111



        clusters1 := []*p.ClusterReplicationConfig{




×







1112



                {




×







1113



                        ClusterName: clusterActive1,




×







1114



                },




×







1115



                {




×







1116



                        ClusterName: clusterStandby1,




×







1117



                },




×







1118



        }




×







1119






×







1120



        clusterActive2 := "other random active cluster name"




×







1121



        clusterStandby2 := "other random standby cluster name"




×







1122



        clusters2 := []*p.ClusterReplicationConfig{




×







1123



                {




×







1124



                        ClusterName: clusterActive2,




×







1125



                },




×







1126



                {




×







1127



                        ClusterName: clusterStandby2,




×







1128



                },




×







1129



        }




×







1130






×







1131



        testBinaries1 := types.BadBinaries{




×







1132



                Binaries: map[string]*types.BadBinaryInfo{




×







1133



                        "abc": {




×







1134



                                Reason:          "test-reason1",




×







1135



                                Operator:        "test-operator1",




×







1136



                                CreatedTimeNano: common.Int64Ptr(123),




×







1137



                        },




×







1138



                },




×







1139



        }




×







1140



        testBinaries2 := types.BadBinaries{




×







1141



                Binaries: map[string]*types.BadBinaryInfo{




×







1142



                        "efg": {




×







1143



                                Reason:          "test-reason2",




×







1144



                                Operator:        "test-operator2",




×







1145



                                CreatedTimeNano: common.Int64Ptr(456),




×







1146



                        },




×







1147



                },




×







1148



        }




×







1149






×








1150



        isolationGroups := types.IsolationGroupConfiguration{}




×







1151



        inputDomains := []*p.GetDomainResponse{




×







1152



                {




×







1153



                        Info: &p.DomainInfo{




×







1154



                                ID:          uuid.New(),




×







1155



                                Name:        "list-domain-test-name-1",




×







1156



                                Status:      p.DomainStatusRegistered,




×







1157



                                Description: "list-domain-test-description-1",




×







1158



                                OwnerEmail:  "list-domain-test-owner-1",




×







1159



                                Data:        map[string]string{"k1": "v1"},




×







1160



                        },




×







1161



                        Config: &p.DomainConfig{




×







1162



                                Retention:                109,




×







1163



                                EmitMetric:               true,




×







1164



                                HistoryArchivalStatus:    types.ArchivalStatusEnabled,




×







1165



                                HistoryArchivalURI:       "test://history/uri",




×







1166



                                VisibilityArchivalStatus: types.ArchivalStatusEnabled,




×







1167



                                VisibilityArchivalURI:    "test://visibility/uri",




×







1168



                                BadBinaries:              testBinaries1,




×








1169



                                IsolationGroups:          isolationGroups,




×







1170



                        },




×







1171



                        ReplicationConfig: &p.DomainReplicationConfig{




×







1172



                                ActiveClusterName: clusterActive1,




×







1173



                                Clusters:          clusters1,




×







1174



                        },




×







1175



                        IsGlobalDomain:          true,




×







1176



                        ConfigVersion:           133,




×







1177



                        FailoverVersion:         266,




×







1178



                        PreviousFailoverVersion: -1,




×







1179



                },




×







1180



                {




×







1181



                        Info: &p.DomainInfo{




×







1182



                                ID:          uuid.New(),




×







1183



                                Name:        "list-domain-test-name-2",




×







1184



                                Status:      p.DomainStatusRegistered,




×







1185



                                Description: "list-domain-test-description-2",




×







1186



                                OwnerEmail:  "list-domain-test-owner-2",




×







1187



                                Data:        map[string]string{"k1": "v2"},




×







1188



                        },




×







1189



                        Config: &p.DomainConfig{




×







1190



                                Retention:                326,




×







1191



                                EmitMetric:               false,




×







1192



                                HistoryArchivalStatus:    types.ArchivalStatusDisabled,




×







1193



                                HistoryArchivalURI:       "",




×







1194



                                VisibilityArchivalStatus: types.ArchivalStatusDisabled,




×







1195



                                VisibilityArchivalURI:    "",




×







1196



                                BadBinaries:              testBinaries2,




×








1197



                                IsolationGroups:          isolationGroups,




×







1198



                        },




×







1199



                        ReplicationConfig: &p.DomainReplicationConfig{




×







1200



                                ActiveClusterName: clusterActive2,




×







1201



                                Clusters:          clusters2,




×







1202



                        },




×







1203



                        IsGlobalDomain:          false,




×







1204



                        ConfigVersion:           400,




×







1205



                        FailoverVersion:         667,




×







1206



                        PreviousFailoverVersion: -1,




×







1207



                },




×







1208



        }




×







1209



        for _, domain := range inputDomains {




×







1210



                _, err := m.CreateDomain(




×







1211



                        ctx,




×







1212



                        domain.Info,




×







1213



                        domain.Config,




×







1214



                        domain.ReplicationConfig,




×







1215



                        domain.IsGlobalDomain,




×







1216



                        domain.ConfigVersion,




×







1217



                        domain.FailoverVersion,




×







1218



                        0,




×







1219



                )




×







1220



                m.NoError(err)




×







1221



        }




×







1222












1223



        var token []byte




×







1224



        pageSize := 1




×







1225



        outputDomains := make(map[string]*p.GetDomainResponse)




×







1226



ListLoop:




×







1227



        for {




×







1228



                resp, err := m.ListDomains(ctx, pageSize, token)




×







1229



                m.NoError(err)




×







1230



                token = resp.NextPageToken




×







1231



                for _, domain := range resp.Domains {




×







1232



                        outputDomains[domain.Info.ID] = domain




×







1233



                        // global notification version is already tested, so here we make it 0




×







1234



                        // so we can test == easily




×







1235



                        domain.NotificationVersion = 0




×







1236



                }




×







1237



                if len(token) == 0 {




×







1238



                        break ListLoop




×







1239



                }










1240



        }










1241












1242



        m.Equal(len(inputDomains), len(outputDomains))




×







1243



        for _, domain := range inputDomains {




×







1244



                m.Equal(domain, outputDomains[domain.Info.ID])




×







1245



        }




×







1246



}










1247












1248



// CreateDomain helper method










1249



func (m *MetadataPersistenceSuiteV2) CreateDomain(










1250



        ctx context.Context,










1251



        info *p.DomainInfo,










1252



        config *p.DomainConfig,










1253



        replicationConfig *p.DomainReplicationConfig,










1254



        isGlobaldomain bool,










1255



        configVersion int64,










1256



        failoverVersion int64,










1257



        lastUpdateTime int64,










1258



) (*p.CreateDomainResponse, error) {




×







1259






×







1260



        return m.DomainManager.CreateDomain(ctx, &p.CreateDomainRequest{




×







1261



                Info:              info,




×







1262



                Config:            config,




×







1263



                ReplicationConfig: replicationConfig,




×







1264



                IsGlobalDomain:    isGlobaldomain,




×







1265



                ConfigVersion:     configVersion,




×







1266



                FailoverVersion:   failoverVersion,




×







1267



                LastUpdatedTime:   lastUpdateTime,




×







1268



        })




×







1269



}




×







1270












1271



// GetDomain helper method










1272



func (m *MetadataPersistenceSuiteV2) GetDomain(ctx context.Context, id, name string) (*p.GetDomainResponse, error) {




×







1273



        return m.DomainManager.GetDomain(ctx, &p.GetDomainRequest{




×







1274



                ID:   id,




×







1275



                Name: name,




×







1276



        })




×







1277



}




×







1278












1279



// UpdateDomain helper method










1280



func (m *MetadataPersistenceSuiteV2) UpdateDomain(










1281



        ctx context.Context,










1282



        info *p.DomainInfo,










1283



        config *p.DomainConfig,










1284



        replicationConfig *p.DomainReplicationConfig,










1285



        configVersion int64,










1286



        failoverVersion int64,










1287



        failoverNotificationVersion int64,










1288



        PreviousFailoverVersion int64,










1289



        failoverEndTime *int64,










1290



        notificationVersion int64,










1291



        lastUpdateTime int64,










1292



) error {




×







1293






×







1294



        return m.DomainManager.UpdateDomain(ctx, &p.UpdateDomainRequest{




×







1295



                Info:                        info,




×







1296



                Config:                      config,




×







1297



                ReplicationConfig:           replicationConfig,




×







1298



                FailoverEndTime:             failoverEndTime,




×







1299



                ConfigVersion:               configVersion,




×







1300



                FailoverVersion:             failoverVersion,




×







1301



                FailoverNotificationVersion: failoverNotificationVersion,




×







1302



                PreviousFailoverVersion:     PreviousFailoverVersion,




×







1303



                NotificationVersion:         notificationVersion,




×







1304



                LastUpdatedTime:             lastUpdateTime,




×







1305



        })




×







1306



}




×







1307












1308



// DeleteDomain helper method










1309



func (m *MetadataPersistenceSuiteV2) DeleteDomain(ctx context.Context, id, name string) error {




×







1310



        if len(id) > 0 {




×







1311



                return m.DomainManager.DeleteDomain(ctx, &p.DeleteDomainRequest{ID: id})




×







1312



        }




×







1313



        return m.DomainManager.DeleteDomainByName(ctx, &p.DeleteDomainByNameRequest{Name: name})




×







1314



}










1315












1316



// ListDomains helper method










1317



func (m *MetadataPersistenceSuiteV2) ListDomains(ctx context.Context, pageSize int, pageToken []byte) (*p.ListDomainsResponse, error) {




×







1318



        return m.DomainManager.ListDomains(ctx, &p.ListDomainsRequest{




×







1319



                PageSize:      pageSize,




×







1320



                NextPageToken: pageToken,




×







1321



        })




×







1322



}




×





















    

  • 

    •