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         credAppRole "github.com/hashicorp/vault/builtin/credential/approle"
  21         vaulthttp "github.com/hashicorp/vault/http"
  22         vaultlogical "github.com/hashicorp/vault/logical"
  23         vaulttesting "github.com/hashicorp/vault/vault"
  24         "reflect"
  25         smslog "sms/log"
  26         "testing"
  27 )
  28
  29 var secret Secret
  30
  31 func init() {
  32         smslog.Init("")
  33         secret = Secret{
  34                 Name: "testsecret",
  35                 Values: map[string]interface{}{
  36                         "name":    "john",
  37                         "age":     "43",
  38                         "isadmin": "true",
  39                 },
  40         }
  41 }
  42
  43 // Only needed when running tests against vault
  44 func createLocalVaultServer(t *testing.T) (*vaulttesting.TestCluster, *Vault) {
  45         tc := vaulttesting.NewTestCluster(t,
  46                 &vaulttesting.CoreConfig{
  47                         DisableCache: true,
  48                         DisableMlock: true,
  49                         CredentialBackends: map[string]vaultlogical.Factory{
  50                                 "approle": credAppRole.Factory,
  51                         },
  52                 },
  53                 &vaulttesting.TestClusterOptions{
  54                         HandlerFunc: vaulthttp.Handler,
  55                         NumCores:    1,
  56                 })
  57
  58         tc.Start()
  59
  60         v := &Vault{}
  61         v.initVaultClient()
  62         v.vaultToken = tc.RootToken
  63         v.vaultClient = tc.Cores[0].Client
  64
  65         return tc, v
  66 }
  67
  68 func TestInitVaultClient(t *testing.T) {
  69
  70         v := &Vault{}
  71         v.vaultAddress = "https://localhost:8200"
  72         err := v.initVaultClient()
  73         if err != nil || v.vaultClient == nil {
  74                 t.Fatal("Init: Init() failed to create vaultClient")
  75         }
  76 }
  77
  78 func TestInitRole(t *testing.T) {
  79
  80         tc, v := createLocalVaultServer(t)
  81         defer tc.Cleanup()
  82
  83         v.vaultToken = tc.RootToken
  84         v.vaultClient = tc.Cores[0].Client
  85
  86         err := v.initRole()
  87
  88         if err != nil {
  89                 t.Fatal("InitRole: InitRole() failed to create roles")
  90         }
  91 }
  92
  93 func TestGetStatus(t *testing.T) {
  94
  95         tc, v := createLocalVaultServer(t)
  96         defer tc.Cleanup()
  97
  98         st, err := v.GetStatus()
  99
 100         if err != nil {
 101                 t.Fatal("GetStatus: Returned error")
 102         }
 103
 104         if st == true {
 105                 t.Fatal("GetStatus: Returned true. Expected false")
 106         }
 107 }
 108
 109 func TestCreateSecretDomain(t *testing.T) {
 110
 111         tc, v := createLocalVaultServer(t)
 112         defer tc.Cleanup()
 113
 114         sd, err := v.CreateSecretDomain("testdomain")
 115
 116         if err != nil {
 117                 t.Fatal("CreateSecretDomain: Returned error")
 118         }
 119
 120         if sd.Name != "testdomain" {
 121                 t.Fatal("CreateSecretDomain: Returned name does not match: " + sd.Name)
 122         }
 123
 124         if sd.UUID == "" {
 125                 t.Fatal("CreateSecretDomain: Returned UUID is empty")
 126         }
 127 }
 128
 129 func TestDeleteSecretDomain(t *testing.T) {
 130
 131         tc, v := createLocalVaultServer(t)
 132         defer tc.Cleanup()
 133
 134         _, err := v.CreateSecretDomain("testdomain")
 135         if err != nil {
 136                 t.Fatal(err)
 137         }
 138
 139         err = v.DeleteSecretDomain("testdomain")
 140         if err != nil {
 141                 t.Fatal("DeleteSecretDomain: Unable to delete domain")
 142         }
 143 }
 144
 145 func TestCreateSecret(t *testing.T) {
 146
 147         tc, v := createLocalVaultServer(t)
 148         defer tc.Cleanup()
 149
 150         _, err := v.CreateSecretDomain("testdomain")
 151         if err != nil {
 152                 t.Fatal(err)
 153         }
 154
 155         err = v.CreateSecret("testdomain", secret)
 156
 157         if err != nil {
 158                 t.Fatal("CreateSecret: Error Creating secret")
 159         }
 160 }
 161
 162 func TestGetSecret(t *testing.T) {
 163
 164         tc, v := createLocalVaultServer(t)
 165         defer tc.Cleanup()
 166
 167         _, err := v.CreateSecretDomain("testdomain")
 168         if err != nil {
 169                 t.Fatal(err)
 170         }
 171
 172         err = v.CreateSecret("testdomain", secret)
 173         if err != nil {
 174                 t.Fatal(err)
 175         }
 176
 177         sec, err := v.GetSecret("testdomain", secret.Name)
 178         if err != nil {
 179                 t.Fatal("GetSecret: Error Creating secret")
 180         }
 181
 182         if sec.Name != secret.Name {
 183                 t.Fatal("GetSecret: Returned incorrect name")
 184         }
 185
 186         if reflect.DeepEqual(sec.Values, secret.Values) == false {
 187                 t.Fatal("GetSecret: Returned incorrect Values")
 188         }
 189 }
 190
 191 func TestListSecret(t *testing.T) {
 192
 193         tc, v := createLocalVaultServer(t)
 194         defer tc.Cleanup()
 195
 196         _, err := v.CreateSecretDomain("testdomain")
 197         if err != nil {
 198                 t.Fatal(err)
 199         }
 200
 201         err = v.CreateSecret("testdomain", secret)
 202         if err != nil {
 203                 t.Fatal(err)
 204         }
 205
 206         _, err = v.ListSecret("testdomain")
 207         if err != nil {
 208                 t.Fatal("ListSecret: Returned error")
 209         }
 210 }
 211
 212 func TestDeleteSecret(t *testing.T) {
 213
 214         tc, v := createLocalVaultServer(t)
 215         defer tc.Cleanup()
 216
 217         _, err := v.CreateSecretDomain("testdomain")
 218         if err != nil {
 219                 t.Fatal(err)
 220         }
 221
 222         err = v.CreateSecret("testdomain", secret)
 223         if err != nil {
 224                 t.Fatal(err)
 225         }
 226
 227         err = v.DeleteSecret("testdomain", secret.Name)
 228         if err != nil {
 229                 t.Fatal("DeleteSecret: Error Creating secret")
 230         }
 231 }