Added all tests for conf params object

server/conf/db.yaml

----
-name: "name"
-username: "username"
-password: "password"
-addresses:
-  - "127.0.0.1:80"
-  - "127.0.0.1:80"
-  - "127.0.0.1:80"
-...

server/conf/db_test.go

@@ -13,11 +13,7 @@ import (
 	"testing"
 )
 
-// This test checks that unmarshalling the db.yaml file
-// is equal to the expected DB object.
-func TestDB_UnmarshallingFileEqualsExpected(t *testing.T) {
-
-	expected := DB{
+var ExpectedDB = DB{
 	Name:     "name",
 	Username: "username",
 	Password: "password",
@@ -28,16 +24,21 @@ func TestDB_UnmarshallingFileEqualsExpected(t *testing.T) {
 	},
 }
 
-	buf, _ := ioutil.ReadFile("./db.yaml")
-	actual := DB{}
+// This test checks that unmarshalling the params.yaml file
+// has the expected DB object.
+func TestDB_UnmarshallingFileEqualsExpected(t *testing.T) {
+
+	buf, _ := ioutil.ReadFile("./params.yaml")
+
+	actual := Params{}
 
 	err := yaml.Unmarshal(buf, &actual)
 	if err != nil {
 		t.Errorf("Unable to decode into struct, %v", err)
 	}
 
-	if !reflect.DeepEqual(expected, actual) {
-		t.Errorf("DB object did not match expected values")
+	if !reflect.DeepEqual(ExpectedDB, actual.Database) {
+		t.Errorf("DB object did not match ExpectedDB values")
 	}
 
 }

server/conf/groups.go

@@ -8,6 +8,7 @@ package conf
 
 import (
 	jww "github.com/spf13/jwalterweatherman"
+	"github.com/spf13/viper"
 	"gitlab.com/elixxir/crypto/cyclic"
 	"gitlab.com/elixxir/crypto/large"
 	"strings"
@@ -19,6 +20,22 @@ type Groups struct {
 	E2E  *cyclic.Group
 }
 
+// NewGroups creates a groups object from
+// a viper config.
+// TODO: This is a hack and UnmarshalYAML
+// should likely be used, but wasn't working
+// with viper.  Perhaps a missing decoder option?
+func NewGroups(vip *viper.Viper) Groups {
+
+	cmix := vip.GetStringMapString("groups.cmix")
+	e2e := vip.GetStringMapString("groups.e2e")
+
+	return Groups{
+		CMix: toGroup(cmix),
+		E2E:  toGroup(e2e),
+	}
+}
+
 // TODO: field names start with a capital by convention
 // but perhaps we should override to force a consistent scheme
 // See yaml package documentation for more info.

server/conf/groups.yaml

----
-cmix:
-  prime: "17"
-  smallprime: "11"
-  generator: "4"
-e2e:
-  prime: "0x11"
-  smallprime: "0x0B"
-  generator: "0x04"
-...

server/conf/groups_test.go

@@ -14,35 +14,35 @@ import (
 	"testing"
 )
 
-// This test checks that unmarshalling the groups.yaml file
-// is equal to the expected groups object.
-func TestGroups_UnmarshallingFileEqualsExpected(t *testing.T) {
+var prime = large.NewInt(int64(17))
+var smallPrime = large.NewInt(int64(11))
+var generator = large.NewInt(int64(4))
 
-	prime := large.NewInt(int64(17))
-	smallPrime := large.NewInt(int64(11))
-	generator := large.NewInt(int64(4))
+var cmix = cyclic.NewGroup(prime, generator, smallPrime)
+var e2e = cyclic.NewGroup(prime, generator, smallPrime)
 
-	cmix := cyclic.NewGroup(prime, generator, smallPrime)
-	e2e := cyclic.NewGroup(prime, generator, smallPrime)
-
-	expected := Groups{
+var ExpectedGroups = Groups{
 	CMix: cmix,
 	E2E:  e2e,
 }
 
-	actual := Groups{}
-	buf, _ := ioutil.ReadFile("./Groups.yaml")
+// This test checks that unmarshalling the groups.yaml file
+// is equal to the expected groups object.
+func TestGroups_UnmarshallingFileEqualsExpected(t *testing.T) {
+
+	actual := Params{}
+	buf, _ := ioutil.ReadFile("./params.yaml")
 
 	err := yaml.Unmarshal(buf, &actual)
 	if err != nil {
 		t.Errorf("Unable to decode into struct, %v", err)
 	}
 
-	if actual.E2E.GetFingerprint() != expected.E2E.GetFingerprint() {
+	if actual.Groups.E2E.GetFingerprint() != ExpectedGroups.E2E.GetFingerprint() {
 		t.Errorf("Groups object did not match expected values for E2E")
 	}
-	if actual.CMix.GetFingerprint() != expected.CMix.GetFingerprint() {
-		t.Errorf("Groups object did not match expected values for E2E")
+	if actual.Groups.CMix.GetFingerprint() != ExpectedGroups.CMix.GetFingerprint() {
+		t.Errorf("Groups object did not match expected values for CMIX")
 	}
 
 }

server/conf/params.go

@@ -6,15 +6,35 @@
 
 package conf
 
+import "github.com/spf13/viper"
+
 // This object is used by the server instance.
 // A viper (or any yaml based) configuration
 // can be unmarshalled into this object.
 // For viper just use Unmarshal(&params).
+// Note not all fields are in the YAML, ie NodeID
+// but all fields must be in the viper object
 type Params struct {
 	Database DB
 	Groups   Groups
 	Paths    Paths
 	Servers  []string
-	NodeID   int  `yaml:"nodeId"`
+	NodeID   uint64
 	SkipReg  bool `yaml:"skipReg"`
 }
+
+// NewParams returns a params object if it is able to
+// unmarshal the viper config, otherwise it returns
+// an error.
+func NewParams(vip *viper.Viper) (*Params, error) {
+
+	params := Params{}
+	err := vip.Unmarshal(&params)
+	if err != nil {
+		return nil, err
+	}
+
+	params.Groups = NewGroups(vip)
+
+	return &params, nil
+}

server/conf/params.yaml

 ---
-# Example yaml params file used for testing params object
+# Example yaml params file used for testing
+# the params object and its dependencies
 database:
   name: "name"
   username: "username"
@@ -25,6 +26,5 @@ servers:
   - "127.0.0.1:80"
   - "127.0.0.1:80"
   - "127.0.0.1:80"
-nodeId: 100
 skipReg: true
 ...
\ No newline at end of file

server/conf/params_test.go

@@ -7,29 +7,64 @@
 package conf
 
 import (
-	"gopkg.in/yaml.v2"
-	"io/ioutil"
+	"github.com/spf13/viper"
+	"reflect"
 	"testing"
 )
 
-// This test checks that unmarshalling the params.yaml file
-// is equal to the expected Params object.
-func TestParams_UnmarshallingFileEqualsExpected(t *testing.T) {
+func TestNewParams_ReturnsParamsWhenGivenValidViper(t *testing.T) {
 
-	buf, _ := ioutil.ReadFile("./params.yaml")
-	actual := Params{}
+	expectedParams := Params{
+		Database: ExpectedDB,
+		Groups:   ExpectedGroups,
+		Paths:    ExpectedPaths,
+		Servers:  []string{"127.0.0.1:80", "127.0.0.1:80", "127.0.0.1:80"},
+		SkipReg:  true,
+		NodeID:   uint64(100),
+	}
+
+	vip := viper.New()
+	vip.AddConfigPath(".")
+	vip.SetConfigFile("params.yaml")
+	vip.Set("NodeID", uint64(100))
+
+	err := vip.ReadInConfig()
+
+	if err != nil {
+		t.Errorf("Failed to read in params.yaml into viper")
+	}
+
+	params, err := NewParams(vip)
 
-	err := yaml.Unmarshal(buf, &actual)
 	if err != nil {
-		t.Errorf("Unable to decode into struct, %v", err)
+		t.Errorf("Failed in unmarshaling from viper object")
+	}
+
+	if !reflect.DeepEqual(expectedParams.Servers, params.Servers) {
+		t.Errorf("Servers value does not match expected value")
+	}
+
+	if !reflect.DeepEqual(expectedParams.NodeID, params.NodeID) {
+		t.Errorf("NodeId value does not match expected value")
+	}
+
+	if !reflect.DeepEqual(expectedParams.SkipReg, params.SkipReg) {
+		t.Errorf("SkipReg value does not match expected value")
+	}
+
+	if params.Groups.E2E.GetFingerprint() != ExpectedGroups.E2E.GetFingerprint() {
+		t.Errorf("E2E object did not match expected values for E2E")
+	}
+	if params.Groups.CMix.GetFingerprint() != ExpectedGroups.CMix.GetFingerprint() {
+		t.Errorf("CMIX object did not match expected values for CMIX")
 	}
 
-	if actual.NodeID != 100 {
-		t.Errorf("Params object did not match expected value for NodeID")
+	if !reflect.DeepEqual(expectedParams.Paths, params.Paths) {
+		t.Errorf("Paths value does not match expected value")
 	}
 
-	if actual.SkipReg != true {
-		t.Errorf("Params object did not match expected value for SkipReg")
+	if !reflect.DeepEqual(expectedParams.Database, params.Database) {
+		t.Errorf("v value does not match expected value")
 	}
 
 }

server/conf/paths.yaml

----
-cert: "~/.elixxir/cert.crt"
-key:  "~/.elixxir/key.pem"
-log:  "~/.elixxir/server.log"
-...
\ No newline at end of file

server/conf/paths_test.go

@@ -13,26 +13,26 @@ import (
 	"testing"
 )
 
-// This test checks that unmarshalling the path.yaml file
-// is equal to the expected Paths object.
-func TestPaths_UnmarshallingFileEqualsExpected(t *testing.T) {
-
-	expected := Paths{
+var ExpectedPaths = Paths{
 	Cert: "~/.elixxir/cert.crt",
 	Key:  "~/.elixxir/key.pem",
 	Log:  "~/.elixxir/server.log",
 }
 
-	buf, _ := ioutil.ReadFile("./paths.yaml")
-	actual := Paths{}
+// This test checks that unmarshalling the path.yaml file
+// is equal to the expected Paths object.
+func TestPaths_UnmarshallingFileEqualsExpected(t *testing.T) {
+
+	buf, _ := ioutil.ReadFile("./params.yaml")
+	actual := Params{}
 
 	err := yaml.Unmarshal(buf, &actual)
 	if err != nil {
 		t.Errorf("Unable to decode into struct, %v", err)
 	}
 
-	if !reflect.DeepEqual(expected, actual) {
-		t.Errorf("Paths object did not match expected values")
+	if !reflect.DeepEqual(ExpectedPaths, actual.Paths) {
+		t.Errorf("Paths object did not match ExpectedPaths values")
 	}
 
 }