Add a bunch of default basic unittests to boost coverage

rtcbundlepolicy.go

@@ -16,6 +16,19 @@ const (
 	RTCBundlePolicyMaxBundle
 )
 
+func NewRTCBundlePolicy(raw string) (unknown RTCBundlePolicy) {
+	switch raw {
+	case "balanced":
+		return RTCBundlePolicyBalanced
+	case "max-compat":
+		return RTCBundlePolicyMaxCompat
+	case "max-bundle":
+		return RTCBundlePolicyMaxBundle
+	default:
+		return unknown
+	}
+}
+
 func (t RTCBundlePolicy) String() string {
 	switch t {
 	case RTCBundlePolicyBalanced:

rtcbundlepolicy_test.go

@@ -0,0 +1,46 @@
+package webrtc
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestNewRTCBundlePolicy(t *testing.T) {
+	testCases := []struct {
+		policyString   string
+		expectedPolicy RTCBundlePolicy
+	}{
+		{"unknown", RTCBundlePolicy(Unknown)},
+		{"balanced", RTCBundlePolicyBalanced},
+		{"max-compat", RTCBundlePolicyMaxCompat},
+		{"max-bundle", RTCBundlePolicyMaxBundle},
+	}
+
+	for i, testCase := range testCases {
+		assert.Equal(t,
+			NewRTCBundlePolicy(testCase.policyString),
+			testCase.expectedPolicy,
+			"testCase: %d %v", i, testCase,
+		)
+	}
+}
+
+func TestRTCBundlePolicy_String(t *testing.T) {
+	testCases := []struct {
+		policy         RTCBundlePolicy
+		expectedString string
+	}{
+		{RTCBundlePolicy(Unknown), "unknown"},
+		{RTCBundlePolicyBalanced, "balanced"},
+		{RTCBundlePolicyMaxCompat, "max-compat"},
+		{RTCBundlePolicyMaxBundle, "max-bundle"},
+	}
+
+	for i, testCase := range testCases {
+		assert.Equal(t,
+			testCase.policy.String(),
+			testCase.expectedString,
+			"testCase: %d %v", i, testCase,
+		)
+	}
+}

rtccertificate.go

@@ -3,13 +3,13 @@ package webrtc
 import (
 	"crypto"
 	"crypto/ecdsa"
+	"crypto/rand"
 	"crypto/rsa"
 	"crypto/x509"
-	"time"
 	"crypto/x509/pkix"
 	"encoding/hex"
-	"crypto/rand"
 	"math/big"
+	"time"
 )
 
 // RTCCertificate represents a x509Cert used to authenticate WebRTC communications.

rtcicecredentialtype.go

@@ -10,6 +10,17 @@ const (
 	RTCIceCredentialTypeOauth
 )
 
+func NewRTCIceCredentialType(raw string) (unknown RTCIceCredentialType) {
+	switch raw {
+	case "password":
+		return RTCIceCredentialTypePassword
+	case "oauth":
+		return RTCIceCredentialTypeOauth
+	default:
+		return unknown
+	}
+}
+
 func (t RTCIceCredentialType) String() string {
 	switch t {
 	case RTCIceCredentialTypePassword:

rtcicecredentialtype_test.go

@@ -0,0 +1,44 @@
+package webrtc
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestNewRTCIceCredentialType(t *testing.T) {
+	testCases := []struct {
+		credentialTypeString   string
+		expectedCredentialType RTCIceCredentialType
+	}{
+		{"unknown", RTCIceCredentialType(Unknown)},
+		{"password", RTCIceCredentialTypePassword},
+		{"oauth", RTCIceCredentialTypeOauth},
+	}
+
+	for i, testCase := range testCases {
+		assert.Equal(t,
+			NewRTCIceCredentialType(testCase.credentialTypeString),
+			testCase.expectedCredentialType,
+			"testCase: %d %v", i, testCase,
+		)
+	}
+}
+
+func TestRTCIceCredentialType_String(t *testing.T) {
+	testCases := []struct {
+		credentialType RTCIceCredentialType
+		expectedString string
+	}{
+		{RTCIceCredentialType(Unknown), "unknown"},
+		{RTCIceCredentialTypePassword, "password"},
+		{RTCIceCredentialTypeOauth, "oauth"},
+	}
+
+	for i, testCase := range testCases {
+		assert.Equal(t,
+			testCase.credentialType.String(),
+			testCase.expectedString,
+			"testCase: %d %v", i, testCase,
+		)
+	}
+}

rtcicetransportpolicy.go

@@ -13,6 +13,17 @@ const (
 	RTCIceTransportPolicyAll
 )
 
+func NewRTCIceTransportPolicy(raw string) (unknown RTCIceTransportPolicy) {
+	switch raw {
+	case "relay":
+		return RTCIceTransportPolicyRelay
+	case "all":
+		return RTCIceTransportPolicyAll
+	default:
+		return unknown
+	}
+}
+
 func (t RTCIceTransportPolicy) String() string {
 	switch t {
 	case RTCIceTransportPolicyRelay:

rtcicetransportpolicy_test.go

@@ -0,0 +1,44 @@
+package webrtc
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestNewRTCIceTransportPolicy(t *testing.T) {
+	testCases := []struct {
+		policyString   string
+		expectedPolicy RTCIceTransportPolicy
+	}{
+		{"unknown", RTCIceTransportPolicy(Unknown)},
+		{"relay", RTCIceTransportPolicyRelay},
+		{"all", RTCIceTransportPolicyAll},
+	}
+
+	for i, testCase := range testCases {
+		assert.Equal(t,
+			NewRTCIceTransportPolicy(testCase.policyString),
+			testCase.expectedPolicy,
+			"testCase: %d %v", i, testCase,
+		)
+	}
+}
+
+func TestRTCIceTransportPolicy_String(t *testing.T) {
+	testCases := []struct {
+		policy         RTCIceTransportPolicy
+		expectedString string
+	}{
+		{RTCIceTransportPolicy(Unknown), "unknown"},
+		{RTCIceTransportPolicyRelay, "relay"},
+		{RTCIceTransportPolicyAll, "all"},
+	}
+
+	for i, testCase := range testCases {
+		assert.Equal(t,
+			testCase.policy.String(),
+			testCase.expectedString,
+			"testCase: %d %v", i, testCase,
+		)
+	}
+}

rtcpeerconnection.go

@@ -123,7 +123,7 @@ func (pc *RTCPeerConnection) initConfiguration(configuration RTCConfiguration) e
 			if !x509Cert.Expires().IsZero() && now.After(x509Cert.Expires()) {
 				return &InvalidAccessError{ErrCertificateExpired}
 			}
-			pc.configuration.Certificates = append(pc.configuration.Certificates, x509Cert, )
+			pc.configuration.Certificates = append(pc.configuration.Certificates, x509Cert)
 		}
 	} else {
 		sk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)

rtcpeerconnection_test.go

@@ -4,11 +4,11 @@ import (
 	"crypto/ecdsa"
 	"crypto/elliptic"
 	"crypto/rand"
-	"github.com/stretchr/testify/assert"
-	"testing"
 	"crypto/x509"
-	"time"
+	"github.com/stretchr/testify/assert"
 	"math/big"
+	"testing"
+	"time"
 )
 
 func TestNew(t *testing.T) {

rtcsdptype.go

@@ -19,6 +19,21 @@ const (
 	RTCSdpTypeRollback
 )
 
+func NewRTCSdpType(raw string) (unknown RTCSdpType) {
+	switch raw {
+	case "offer":
+		return RTCSdpTypeOffer
+	case "pranswer":
+		return RTCSdpTypePranswer
+	case "answer":
+		return RTCSdpTypeAnswer
+	case "rollback":
+		return RTCSdpTypeRollback
+	default:
+		return unknown
+	}
+}
+
 func (t RTCSdpType) String() string {
 	switch t {
 	case RTCSdpTypeOffer:

rtcsdptype_test.go

@@ -0,0 +1,48 @@
+package webrtc
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestNewRTCSdpType(t *testing.T) {
+	testCases := []struct {
+		sdpTypeString   string
+		expectedSdpType RTCSdpType
+	}{
+		{"unknown", RTCSdpType(Unknown)},
+		{"offer", RTCSdpTypeOffer},
+		{"pranswer", RTCSdpTypePranswer},
+		{"answer", RTCSdpTypeAnswer},
+		{"rollback", RTCSdpTypeRollback},
+	}
+
+	for i, testCase := range testCases {
+		assert.Equal(t,
+			NewRTCSdpType(testCase.sdpTypeString),
+			testCase.expectedSdpType,
+			"testCase: %d %v", i, testCase,
+		)
+	}
+}
+
+func TestRTCSdpType_String(t *testing.T) {
+	testCases := []struct {
+		sdpType        RTCSdpType
+		expectedString string
+	}{
+		{RTCSdpType(Unknown), "unknown"},
+		{RTCSdpTypeOffer, "offer"},
+		{RTCSdpTypePranswer, "pranswer"},
+		{RTCSdpTypeAnswer, "answer"},
+		{RTCSdpTypeRollback, "rollback"},
+	}
+
+	for i, testCase := range testCases {
+		assert.Equal(t,
+			testCase.sdpType.String(),
+			testCase.expectedString,
+			"testCase: %d %v", i, testCase,
+		)
+	}
+}

rtcsignalingstate.go

@@ -1,6 +1,6 @@
 package webrtc
 
-// RTCSignalingState indicates the state of the offer/answer process
+// RTCSignalingState indicates the policy of the offer/answer process
 type RTCSignalingState int
 
 const (

rtcsignalingstate_test.go

@@ -20,11 +20,15 @@ func TestNewRTCSignalingState(t *testing.T) {
 	}
 
 	for i, testCase := range testCases {
-		assert.Equal(t, NewRTCSignalingState(testCase.stateString), testCase.expectedState, "testCase: %d %v", i, testCase)
+		assert.Equal(t,
+			NewRTCSignalingState(testCase.stateString),
+			testCase.expectedState,
+			"testCase: %d %v", i, testCase,
+		)
 	}
 }
 
-func TestString(t *testing.T) {
+func TestRTCSignalingState_String(t *testing.T) {
 	testCases := []struct {
 		state          RTCSignalingState
 		expectedString string
@@ -39,6 +43,10 @@ func TestString(t *testing.T) {
 	}
 
 	for i, testCase := range testCases {
-		assert.Equal(t, testCase.state.String(), testCase.expectedString, "testCase: %d %v", i, testCase)
+		assert.Equal(t,
+			testCase.state.String(),
+			testCase.expectedString,
+			"testCase: %d %v", i, testCase,
+		)
 	}
 }