sms-service/src/sms/backend/vault_test.go

   1 /*
   2  * Copyright 2018 Intel Corporation, Inc
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package backend
  18
  19 import (
  20         vaultapi "github.com/hashicorp/vault/api"
  21         credAppRole "github.com/hashicorp/vault/builtin/credential/approle"
  22         vaulthttp "github.com/hashicorp/vault/http"
  23         vaultlogical "github.com/hashicorp/vault/logical"
  24         vaultinmem "github.com/hashicorp/vault/physical/inmem"
  25         vaulttesting "github.com/hashicorp/vault/vault"
  26         "reflect"
  27         smslog "sms/log"
  28         "testing"
  29 )
  30
  31 var secret Secret
  32
  33 func init() {
  34         smslog.Init("")
  35         secret = Secret{
  36                 Name: "testsecret",
  37                 Values: map[string]interface{}{
  38                         "name":    "john",
  39                         "age":     "43",
  40                         "isadmin": "true",
  41                 },
  42         }
  43 }
  44
  45 // Only needed when running tests against vault
  46 func createLocalVaultServer(t *testing.T) (*vaulttesting.TestCluster, *Vault) {
  47         tc := vaulttesting.NewTestCluster(t,
  48                 &vaulttesting.CoreConfig{
  49                         DisableCache: true,
  50                         DisableMlock: true,
  51                         CredentialBackends: map[string]vaultlogical.Factory{
  52                                 "approle": credAppRole.Factory,
  53                         },
  54                 },
  55                 &vaulttesting.TestClusterOptions{
  56                         HandlerFunc: vaulthttp.Handler,
  57                         NumCores:    1,
  58                 })
  59
  60         tc.Start()
  61
  62         v := &Vault{}
  63         v.initVaultClient()
  64         v.vaultToken = tc.RootToken
  65         v.vaultClient = tc.Cores[0].Client
  66
  67         return tc, v
  68 }
  69
  70 func TestInitVaultClient(t *testing.T) {
  71
  72         v := &Vault{}
  73         v.vaultAddress = "https://localhost:8200"
  74         err := v.initVaultClient()
  75         if err != nil || v.vaultClient == nil {
  76                 t.Fatal("Init: Init() failed to create vaultClient")
  77         }
  78 }
  79
  80 func TestInitRole(t *testing.T) {
  81
  82         tc, v := createLocalVaultServer(t)
  83         defer tc.Cleanup()
  84
  85         v.vaultToken = tc.RootToken
  86         v.vaultClient = tc.Cores[0].Client
  87
  88         err := v.initRole()
  89
  90         if err != nil {
  91                 t.Fatal("InitRole: InitRole() failed to create roles")
  92         }
  93 }
  94
  95 func TestGetStatus(t *testing.T) {
  96
  97         tc, v := createLocalVaultServer(t)
  98         defer tc.Cleanup()
  99
 100         st, err := v.GetStatus()
 101
 102         if err != nil {
 103                 t.Fatal("GetStatus: Returned error")
 104         }
 105
 106         if st == true {
 107                 t.Fatal("GetStatus: Returned true. Expected false")
 108         }
 109 }
 110
 111 func TestCreateSecretDomain(t *testing.T) {
 112
 113         tc, v := createLocalVaultServer(t)
 114         defer tc.Cleanup()
 115
 116         sd, err := v.CreateSecretDomain("testdomain")
 117
 118         if err != nil {
 119                 t.Fatal("CreateSecretDomain: Returned error")
 120         }
 121
 122         if sd.Name != "testdomain" {
 123                 t.Fatal("CreateSecretDomain: Returned name does not match: " + sd.Name)
 124         }
 125
 126         if sd.UUID == "" {
 127                 t.Fatal("CreateSecretDomain: Returned UUID is empty")
 128         }
 129 }
 130
 131 func TestDeleteSecretDomain(t *testing.T) {
 132
 133         tc, v := createLocalVaultServer(t)
 134         defer tc.Cleanup()
 135
 136         _, err := v.CreateSecretDomain("testdomain")
 137         if err != nil {
 138                 t.Fatal(err)
 139         }
 140
 141         err = v.DeleteSecretDomain("testdomain")
 142         if err != nil {
 143                 t.Fatal("DeleteSecretDomain: Unable to delete domain")
 144         }
 145 }
 146
 147 func TestCreateSecret(t *testing.T) {
 148
 149         tc, v := createLocalVaultServer(t)
 150         defer tc.Cleanup()
 151
 152         _, err := v.CreateSecretDomain("testdomain")
 153         if err != nil {
 154                 t.Fatal(err)
 155         }
 156
 157         err = v.CreateSecret("testdomain", secret)
 158
 159         if err != nil {
 160                 t.Fatal("CreateSecret: Error Creating secret")
 161         }
 162 }
 163
 164 func TestGetSecret(t *testing.T) {
 165
 166         tc, v := createLocalVaultServer(t)
 167         defer tc.Cleanup()
 168
 169         _, err := v.CreateSecretDomain("testdomain")
 170         if err != nil {
 171                 t.Fatal(err)
 172         }
 173
 174         err = v.CreateSecret("testdomain", secret)
 175         if err != nil {
 176                 t.Fatal(err)
 177         }
 178
 179         sec, err := v.GetSecret("testdomain", secret.Name)
 180         if err != nil {
 181                 t.Fatal("GetSecret: Error Getting secret")
 182         }
 183
 184         if sec.Name != secret.Name {
 185                 t.Fatal("GetSecret: Returned incorrect name")
 186         }
 187
 188         if reflect.DeepEqual(sec.Values, secret.Values) == false {
 189                 t.Fatal("GetSecret: Returned incorrect Values")
 190         }
 191 }
 192
 193 func TestListSecret(t *testing.T) {
 194
 195         tc, v := createLocalVaultServer(t)
 196         defer tc.Cleanup()
 197
 198         _, err := v.CreateSecretDomain("testdomain")
 199         if err != nil {
 200                 t.Fatal(err)
 201         }
 202
 203         err = v.CreateSecret("testdomain", secret)
 204         if err != nil {
 205                 t.Fatal(err)
 206         }
 207
 208         _, err = v.ListSecret("testdomain")
 209         if err != nil {
 210                 t.Fatal("ListSecret: Returned error")
 211         }
 212 }
 213
 214 func TestDeleteSecret(t *testing.T) {
 215
 216         tc, v := createLocalVaultServer(t)
 217         defer tc.Cleanup()
 218
 219         _, err := v.CreateSecretDomain("testdomain")
 220         if err != nil {
 221                 t.Fatal(err)
 222         }
 223
 224         err = v.CreateSecret("testdomain", secret)
 225         if err != nil {
 226                 t.Fatal(err)
 227         }
 228
 229         err = v.DeleteSecret("testdomain", secret.Name)
 230         if err != nil {
 231                 t.Fatal("DeleteSecret: Error Creating secret")
 232         }
 233 }
 234
 235 func TestInitializeVault(t *testing.T) {
 236
 237         inm, err := vaultinmem.NewInmem(nil, nil)
 238         if err != nil {
 239                 t.Fatal(err)
 240         }
 241
 242         core, err := vaulttesting.NewCore(&vaulttesting.CoreConfig{
 243                 DisableMlock: true,
 244                 DisableCache: true,
 245                 Physical:     inm,
 246         })
 247         if err != nil {
 248                 t.Fatal(err)
 249         }
 250
 251         ln, addr := vaulthttp.TestServer(t, core)
 252         defer ln.Close()
 253
 254         client, err := vaultapi.NewClient(&vaultapi.Config{
 255                 Address: addr,
 256         })
 257         if err != nil {
 258                 t.Fatal(err)
 259         }
 260
 261         v := &Vault{}
 262         v.initVaultClient()
 263         v.vaultClient = client
 264
 265         err = v.initializeVault()
 266         if err != nil {
 267                 t.Fatal("InitializeVault: Error initializing Vault")
 268         }
 269 }