github.com/willyham/dosa@v2.3.1-0.20171024181418-1e446d37ee71+incompatible/registry_test.go (about) 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 dosa_test 22 23 import ( 24 "reflect" 25 "sort" 26 "strings" 27 "testing" 28 29 "github.com/stretchr/testify/assert" 30 31 "github.com/uber-go/dosa" 32 ) 33 34 type RegistryTestValid struct { 35 dosa.Entity `dosa:"primaryKey=(ID, Name)"` 36 ID int64 37 Name string 38 Email string 39 } 40 41 type RegistryTestInvalid struct { 42 dosa.Entity `dosa:"primaryKey=()"` 43 PrimaryKey int64 44 data string 45 } 46 47 func TestNewRegisteredEntity(t *testing.T) { 48 table, _ := dosa.TableFromInstance(&RegistryTestValid{}) 49 scope := "test" 50 namePrefix := "team.service" 51 entityName := "registrytestvalid" 52 version := int32(12) 53 54 re := dosa.NewRegisteredEntity(scope, namePrefix, table) 55 assert.NotNil(t, re) 56 57 info := re.EntityInfo() 58 assert.NotNil(t, info) 59 60 ref := re.SchemaRef() 61 assert.NotNil(t, ref) 62 63 def := re.EntityDefinition() 64 assert.NotNil(t, def) 65 66 re.SetVersion(version) 67 assert.Equal(t, ref.Scope, scope) 68 assert.Equal(t, ref.NamePrefix, namePrefix) 69 assert.Equal(t, ref.EntityName, entityName) 70 assert.Equal(t, ref.Version, version) 71 assert.Equal(t, def.Name, entityName) 72 assert.Equal(t, table.EntityDefinition, *def) 73 } 74 75 func TestRegisteredEntity_KeyFieldValues(t *testing.T) { 76 entity := &RegistryTestValid{ 77 ID: int64(1), 78 Name: "foo", 79 Email: "foo@email.com", 80 } 81 scope := "test" 82 namePrefix := "team.service" 83 table, _ := dosa.TableFromInstance(entity) 84 re := dosa.NewRegisteredEntity(scope, namePrefix, table) 85 86 // invalid primary key 87 assert.Panics(t, func() { 88 re.KeyFieldValues(&RegistryTestInvalid{PrimaryKey: 1}) 89 }) 90 91 // valid 92 fieldValues := re.KeyFieldValues(entity) 93 expected := map[string]dosa.FieldValue{ 94 "id": int64(1), 95 "name": "foo", 96 } 97 assert.Equal(t, fieldValues, expected) 98 } 99 100 func TestRegisteredEntity_ColumnNames(t *testing.T) { 101 entity := &RegistryTestValid{ 102 ID: int64(1), 103 Name: "foo", 104 Email: "foo@email.com", 105 } 106 scope := "test" 107 namePrefix := "team.service" 108 table, _ := dosa.TableFromInstance(entity) 109 re := dosa.NewRegisteredEntity(scope, namePrefix, table) 110 111 // invalid 112 columnNames, err := re.ColumnNames([]string{"ID", "foo"}) 113 assert.Error(t, err) 114 115 // valid 116 columnNames, err = re.ColumnNames([]string{"ID", "Name"}) 117 assert.NoError(t, err) 118 sort.Strings(columnNames) 119 assert.Equal(t, columnNames, []string{"id", "name"}) 120 121 // all 122 columnNames, err = re.ColumnNames([]string{}) 123 assert.NoError(t, err) 124 sort.Strings(columnNames) 125 assert.Equal(t, columnNames, []string{"email", "id", "name"}) 126 127 // alternative all 128 columnNames, err = re.ColumnNames(nil) 129 assert.NoError(t, err) 130 sort.Strings(columnNames) 131 assert.Equal(t, columnNames, []string{"email", "id", "name"}) 132 } 133 134 func TestRegisteredEntity_SetFieldValues(t *testing.T) { 135 entity := &RegistryTestValid{ 136 ID: int64(1), 137 Name: "foo", 138 Email: "foo@email.com", 139 } 140 scope := "test" 141 namePrefix := "team.service" 142 table, _ := dosa.TableFromInstance(entity) 143 re := dosa.NewRegisteredEntity(scope, namePrefix, table) 144 validFieldValues := map[string]dosa.FieldValue{ 145 "id": int64(2), 146 "name": "bar", 147 "email": "bar@email.com", 148 } 149 invalidFieldValues := map[string]dosa.FieldValue{ 150 "id": int64(3), 151 "name": "bar2", 152 "invalid": "invalid", 153 } 154 155 // invalid entity 156 assert.Panics(t, func() { 157 re.SetFieldValues(&RegistryTestInvalid{PrimaryKey: 1}, validFieldValues, []string{"name", "email"}) 158 }) 159 160 // invalid values are skipped 161 re.SetFieldValues(entity, invalidFieldValues, []string{"id", "name", "invalid"}) 162 assert.Equal(t, entity.ID, invalidFieldValues["id"]) 163 assert.Equal(t, entity.Name, invalidFieldValues["name"]) 164 assert.Equal(t, entity.Email, "foo@email.com") 165 166 // valid 167 re.SetFieldValues(entity, validFieldValues, []string{"id", "name", "email"}) 168 assert.Equal(t, entity.ID, validFieldValues["id"]) 169 assert.Equal(t, entity.Name, validFieldValues["name"]) 170 assert.Equal(t, entity.Email, validFieldValues["email"]) 171 } 172 173 func TestRegisteredEntity_OnlyFieldValues(t *testing.T) { 174 table, _ := dosa.TableFromInstance(&RegistryTestValid{}) 175 scope := "test" 176 namePrefix := "team.service" 177 178 re := dosa.NewRegisteredEntity(scope, namePrefix, table) 179 testv := RegistryTestValid{ID: 1, Name: "name", Email: "email"} 180 expected := map[string]dosa.FieldValue{ 181 "id": dosa.FieldValue(int64(1)), 182 "name": dosa.FieldValue("name"), 183 "email": dosa.FieldValue("email")} 184 185 vals, err := re.OnlyFieldValues(&testv, nil) 186 assert.Equal(t, expected, vals) 187 assert.NoError(t, err) 188 vals, err = re.OnlyFieldValues(&testv, []string{}) 189 assert.Equal(t, expected, vals) 190 assert.NoError(t, err) 191 } 192 193 func TestNewRegistrar(t *testing.T) { 194 entities := []dosa.DomainObject{&RegistryTestValid{}} 195 196 _, err := dosa.NewRegistrar("test", "invalid-prefix", entities...) 197 assert.Error(t, err) 198 199 _, err = dosa.NewRegistrar("test", "valid.prefix", entities...) 200 assert.NoError(t, err) 201 } 202 203 func TestRegistrar(t *testing.T) { 204 validEntities := []dosa.DomainObject{&RegistryTestValid{}} 205 invalidEntities := []dosa.DomainObject{&RegistryTestInvalid{}} 206 207 r, err := dosa.NewRegistrar("test", "team.service", validEntities...) 208 assert.NoError(t, err) 209 _, err = dosa.NewRegistrar("test", "team.service", invalidEntities...) 210 assert.Error(t, err) 211 212 for _, e := range validEntities { 213 entityName := strings.ToLower(reflect.TypeOf(e).Elem().Name()) 214 version := int32(1) 215 216 re, err := r.Find(e) 217 assert.NoError(t, err) 218 re.SetVersion(version) 219 220 info := re.EntityInfo() 221 assert.Equal(t, info.Ref.Scope, r.Scope()) 222 assert.Equal(t, info.Ref.NamePrefix, r.NamePrefix()) 223 assert.Equal(t, info.Ref.EntityName, entityName) 224 assert.Equal(t, info.Ref.Version, version) 225 } 226 227 _, err = r.Find(invalidEntities[0]) 228 assert.Error(t, err) 229 230 var registered []*dosa.RegisteredEntity 231 registered, err = r.FindAll() 232 assert.NoError(t, err) 233 assert.Equal(t, len(registered), len(validEntities)) 234 }